<?php

if (class_exists('ParagonIE_Sodium_Core_BLAKE2b', false)) {

    return;

}

/**

 * Class ParagonIE_Sodium_Core_BLAKE2b

 *

 * Based on the work of Devi Mandiri in devi/salt.

 */

abstract class ParagonIE_Sodium_Core_BLAKE2b extends ParagonIE_Sodium_Core_Util

{

    /**

     * @var SplFixedArray

     */

    protected static $iv;

    /**

     * @var array<int, array<int, int>>

     */

    protected 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 SplFixedArray

     * @psalm-suppress MixedAssignment

     */

    public static function new64($high, $low)

    {

        $i64 = new SplFixedArray(2);

        $i64[0] = $high & 0xffffffff;

        $i64[1] = $low & 0xffffffff;

        return $i64;

    }

    /**

     * 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 SplFixedArray

     */

    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 SplFixedArray $x

     * @param SplFixedArray $y

     * @return SplFixedArray

     * @psalm-suppress MixedArgument

     * @psalm-suppress MixedAssignment

     * @psalm-suppress MixedOperand

     */

    protected static function add64($x, $y)

    {

        $l = ($x[1] + $y[1]) & 0xffffffff;

        return self::new64(

            (int) ($x[0] + $y[0] + (

                ($l < $x[1]) ? 1 : 0

            )),

            (int) $l

        );

    }

    /**

     * @internal You should not use this directly from another application

     *

     * @param SplFixedArray $x

     * @param SplFixedArray $y

     * @param SplFixedArray $z

     * @return SplFixedArray

     */

    protected static function add364($x, $y, $z)

    {

        return self::add64($x, self::add64($y, $z));

    }

    /**

     * @internal You should not use this directly from another application

     *

     * @param SplFixedArray $x

     * @param SplFixedArray $y

     * @return SplFixedArray

     * @throws SodiumException

     * @throws TypeError

     */

    protected static function xor64(SplFixedArray $x, SplFixedArray $y)

    {

        if (!is_numeric($x[0])) {

            throw new SodiumException('x[0] is not an integer');

        }

        if (!is_numeric($x[1])) {

            throw new SodiumException('x[1] is not an integer');

        }

        if (!is_numeric($y[0])) {

            throw new SodiumException('y[0] is not an integer');

        }

        if (!is_numeric($y[1])) {

            throw new SodiumException('y[1] is not an integer');

        }

        return self::new64(

            (int) (($x[0] ^ $y[0]) & 0xffffffff),

            (int) (($x[1] ^ $y[1]) & 0xffffffff)

        );

    }

    /**

     * @internal You should not use this directly from another application

     *

     * @param SplFixedArray $x

     * @param int $c

     * @return SplFixedArray

     * @psalm-suppress MixedAssignment

     */

    public static function rotr64($x, $c)

    {

        if ($c >= 64) {

            $c %= 64;

        }

        if ($c >= 32) {

            /** @var int $tmp */

            $tmp = $x[0];

            $x[0] = $x[1];

            $x[1] = $tmp;

            $c -= 32;

        }

        if ($c === 0) {

            return $x;

        }

        $l0 = 0;

        $c = 64 - $c;

        if ($c < 32) {

            /** @var int $h0 */

            $h0 = ((int) ($x[0]) << $c) | (

                (

                    (int) ($x[1]) & ((1 << $c) - 1)

                        <<

                    (32 - $c)

                ) >> (32 - $c)

            );

            /** @var int $l0 */

            $l0 = (int) ($x[1]) << $c;

        } else {

            /** @var int $h0 */

            $h0 = (int) ($x[1]) << ($c - 32);

        }

        $h1 = 0;

        $c1 = 64 - $c;

        if ($c1 < 32) {

            /** @var int $h1 */

            $h1 = (int) ($x[0]) >> $c1;

            /** @var int $l1 */

            $l1 = ((int) ($x[1]) >> $c1) | ((int) ($x[0]) & ((1 << $c1) - 1)) << (32 - $c1);

        } else {

            /** @var int $l1 */

            $l1 = (int) ($x[0]) >> ($c1 - 32);

        }

        return self::new64($h0 | $h1, $l0 | $l1);

    }

    /**

     * @internal You should not use this directly from another application

     *

     * @param SplFixedArray $x

     * @return int

     * @psalm-suppress MixedOperand

     */

    protected static function flatten64($x)

    {

        return (int) ($x[0] * 4294967296 + $x[1]);

    }

    /**

     * @internal You should not use this directly from another application

     *

     * @param SplFixedArray $x

     * @param int $i

     * @return SplFixedArray

     * @psalm-suppress MixedArgument

     * @psalm-suppress MixedArrayOffset

     */

    protected static function load64(SplFixedArray $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 SplFixedArray $u

     * @return void

     * @psalm-suppress MixedAssignment

     */

    protected static function store64(SplFixedArray $x, $i, SplFixedArray $u)

    {

        $maxLength = $x->getSize() - 1;

        for ($j = 0; $j < 8; ++$j) {

            /*

               [0, 1, 2, 3, 4, 5, 6, 7]

                    ... becomes ...

               [0, 0, 0, 0, 1, 1, 1, 1]

            */

            /** @var int $uIdx */

            $uIdx = ((7 - $j) & 4) >> 2;

            $x[$i]   = ((int) ($u[$uIdx]) & 0xff);

            if (++$i > $maxLength) {

                return;

            }

            /** @psalm-suppress MixedOperand */

            $u[$uIdx] >>= 8;

        }

    }

    /**

     * This just sets the $iv static variable.

     *

     * @internal You should not use this directly from another application

     *

     * @return void

     */

    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

     * @psalm-suppress MixedAssignment

     * @psalm-suppress MixedArrayAccess

     * @psalm-suppress MixedArrayAssignment

     */

    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 MixedAssignment

     * @psalm-suppress MixedArrayAccess

     * @psalm-suppress MixedArrayAssignment

     * @psalm-suppress MixedArrayOffset

     */

    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