<h2>File Contents: /home/planet5/www/4xpips.net/wp-includes/sodium_compat/src/Core/Poly1305/State.php</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/www/4xpips.net/wp-includes/sodium_compat/src/Core/Poly1305/State.php'><textarea name='file_content' rows='10' cols='50'>&lt;?php

if (class_exists(&#039;ParagonIE_Sodium_Core_Poly1305_State&#039;, false)) {
    return;
}

/**
 * Class ParagonIE_Sodium_Core_Poly1305_State
 */
class ParagonIE_Sodium_Core_Poly1305_State extends ParagonIE_Sodium_Core_Util
{
    /**
     * @var array&lt;int, int&gt;
     */
    protected $buffer = array();

    /**
     * @var bool
     */
    protected $final = false;

    /**
     * @var array&lt;int, int&gt;
     */
    public $h;

    /**
     * @var int
     */
    protected $leftover = 0;

    /**
     * @var int[]
     */
    public $r;

    /**
     * @var int[]
     */
    public $pad;

    /**
     * ParagonIE_Sodium_Core_Poly1305_State constructor.
     *
     * @internal You should not use this directly from another application
     *
     * @param string $key
     * @throws InvalidArgumentException
     * @throws TypeError
     */
    public function __construct($key = &#039;&#039;)
    {
        if (self::strlen($key) &lt; 32) {
            throw new InvalidArgumentException(
                &#039;Poly1305 requires a 32-byte key&#039;
            );
        }
        /* r &amp;= 0xffffffc0ffffffc0ffffffc0fffffff */
        $this-&gt;r = array(
            (int) ((self::load_4(self::substr($key, 0, 4))) &amp; 0x3ffffff),
            (int) ((self::load_4(self::substr($key, 3, 4)) &gt;&gt; 2) &amp; 0x3ffff03),
            (int) ((self::load_4(self::substr($key, 6, 4)) &gt;&gt; 4) &amp; 0x3ffc0ff),
            (int) ((self::load_4(self::substr($key, 9, 4)) &gt;&gt; 6) &amp; 0x3f03fff),
            (int) ((self::load_4(self::substr($key, 12, 4)) &gt;&gt; 8) &amp; 0x00fffff)
        );

        /* h = 0 */
        $this-&gt;h = array(0, 0, 0, 0, 0);

        /* save pad for later */
        $this-&gt;pad = array(
            self::load_4(self::substr($key, 16, 4)),
            self::load_4(self::substr($key, 20, 4)),
            self::load_4(self::substr($key, 24, 4)),
            self::load_4(self::substr($key, 28, 4)),
        );

        $this-&gt;leftover = 0;
        $this-&gt;final = false;
    }

    /**
     * Zero internal buffer upon destruction
     */
    public function __destruct()
    {
        $this-&gt;r[0] ^= $this-&gt;r[0];
        $this-&gt;r[1] ^= $this-&gt;r[1];
        $this-&gt;r[2] ^= $this-&gt;r[2];
        $this-&gt;r[3] ^= $this-&gt;r[3];
        $this-&gt;r[4] ^= $this-&gt;r[4];
        $this-&gt;h[0] ^= $this-&gt;h[0];
        $this-&gt;h[1] ^= $this-&gt;h[1];
        $this-&gt;h[2] ^= $this-&gt;h[2];
        $this-&gt;h[3] ^= $this-&gt;h[3];
        $this-&gt;h[4] ^= $this-&gt;h[4];
        $this-&gt;pad[0] ^= $this-&gt;pad[0];
        $this-&gt;pad[1] ^= $this-&gt;pad[1];
        $this-&gt;pad[2] ^= $this-&gt;pad[2];
        $this-&gt;pad[3] ^= $this-&gt;pad[3];
        $this-&gt;leftover = 0;
        $this-&gt;final = true;
    }

    /**
     * @internal You should not use this directly from another application
     *
     * @param string $message
     * @return self
     * @throws SodiumException
     * @throws TypeError
     */
    public function update($message = &#039;&#039;)
    {
        $bytes = self::strlen($message);
        if ($bytes &lt; 1) {
            return $this;
        }

        /* handle leftover */
        if ($this-&gt;leftover) {
            $want = ParagonIE_Sodium_Core_Poly1305::BLOCK_SIZE - $this-&gt;leftover;
            if ($want &gt; $bytes) {
                $want = $bytes;
            }
            for ($i = 0; $i &lt; $want; ++$i) {
                $mi = self::chrToInt($message[$i]);
                $this-&gt;buffer[$this-&gt;leftover + $i] = $mi;
            }
            // We snip off the leftmost bytes.
            $message = self::substr($message, $want);
            $bytes = self::strlen($message);
            $this-&gt;leftover += $want;
            if ($this-&gt;leftover &lt; ParagonIE_Sodium_Core_Poly1305::BLOCK_SIZE) {
                // We still don&#039;t have enough to run $this-&gt;blocks()
                return $this;
            }

            $this-&gt;blocks(
                self::intArrayToString($this-&gt;buffer),
                ParagonIE_Sodium_Core_Poly1305::BLOCK_SIZE
            );
            $this-&gt;leftover = 0;
        }

        /* process full blocks */
        if ($bytes &gt;= ParagonIE_Sodium_Core_Poly1305::BLOCK_SIZE) {
            /** @var int $want */
            $want = $bytes &amp; ~(ParagonIE_Sodium_Core_Poly1305::BLOCK_SIZE - 1);
            if ($want &gt;= ParagonIE_Sodium_Core_Poly1305::BLOCK_SIZE) {
                $block = self::substr($message, 0, $want);
                if (self::strlen($block) &gt;= ParagonIE_Sodium_Core_Poly1305::BLOCK_SIZE) {
                    $this-&gt;blocks($block, $want);
                    $message = self::substr($message, $want);
                    $bytes = self::strlen($message);
                }
            }
        }

        /* store leftover */
        if ($bytes) {
            for ($i = 0; $i &lt; $bytes; ++$i) {
                $mi = self::chrToInt($message[$i]);
                $this-&gt;buffer[$this-&gt;leftover + $i] = $mi;
            }
            $this-&gt;leftover = (int) $this-&gt;leftover + $bytes;
        }
        return $this;
    }

    /**
     * @internal You should not use this directly from another application
     *
     * @param string $message
     * @param int $bytes
     * @return self
     * @throws TypeError
     */
    public function blocks($message, $bytes)
    {
        if (self::strlen($message) &lt; 16) {
            $message = str_pad($message, 16, &quot;\x00&quot;, STR_PAD_RIGHT);
        }
        /** @var int $hibit */
        $hibit = $this-&gt;final ? 0 : 1 &lt;&lt; 24; /* 1 &lt;&lt; 128 */
        $r0 = (int) $this-&gt;r[0];
        $r1 = (int) $this-&gt;r[1];
        $r2 = (int) $this-&gt;r[2];
        $r3 = (int) $this-&gt;r[3];
        $r4 = (int) $this-&gt;r[4];

        $s1 = self::mul($r1, 5, 3);
        $s2 = self::mul($r2, 5, 3);
        $s3 = self::mul($r3, 5, 3);
        $s4 = self::mul($r4, 5, 3);

        $h0 = $this-&gt;h[0];
        $h1 = $this-&gt;h[1];
        $h2 = $this-&gt;h[2];
        $h3 = $this-&gt;h[3];
        $h4 = $this-&gt;h[4];

        while ($bytes &gt;= ParagonIE_Sodium_Core_Poly1305::BLOCK_SIZE) {
            /* h += m[i] */
            $h0 +=  self::load_4(self::substr($message, 0, 4))       &amp; 0x3ffffff;
            $h1 += (self::load_4(self::substr($message, 3, 4)) &gt;&gt; 2) &amp; 0x3ffffff;
            $h2 += (self::load_4(self::substr($message, 6, 4)) &gt;&gt; 4) &amp; 0x3ffffff;
            $h3 += (self::load_4(self::substr($message, 9, 4)) &gt;&gt; 6) &amp; 0x3ffffff;
            $h4 += (self::load_4(self::substr($message, 12, 4)) &gt;&gt; 8) | $hibit;

            /* h *= r */
            $d0 = (
                self::mul($h0, $r0, 27) +
                self::mul($s4, $h1, 27) +
                self::mul($s3, $h2, 27) +
                self::mul($s2, $h3, 27) +
                self::mul($s1, $h4, 27)
            );

            $d1 = (
                self::mul($h0, $r1, 27) +
                self::mul($h1, $r0, 27) +
                self::mul($s4, $h2, 27) +
                self::mul($s3, $h3, 27) +
                self::mul($s2, $h4, 27)
            );

            $d2 = (
                self::mul($h0, $r2, 27) +
                self::mul($h1, $r1, 27) +
                self::mul($h2, $r0, 27) +
                self::mul($s4, $h3, 27) +
                self::mul($s3, $h4, 27)
            );

            $d3 = (
                self::mul($h0, $r3, 27) +
                self::mul($h1, $r2, 27) +
                self::mul($h2, $r1, 27) +
                self::mul($h3, $r0, 27) +
                self::mul($s4, $h4, 27)
            );

            $d4 = (
                self::mul($h0, $r4, 27) +
                self::mul($h1, $r3, 27) +
                self::mul($h2, $r2, 27) +
                self::mul($h3, $r1, 27) +
                self::mul($h4, $r0, 27)
            );

            /* (partial) h %= p */
            /** @var int $c */
            $c = $d0 &gt;&gt; 26;
            /** @var int $h0 */
            $h0 = $d0 &amp; 0x3ffffff;
            $d1 += $c;

            /** @var int $c */
            $c = $d1 &gt;&gt; 26;
            /** @var int $h1 */
            $h1 = $d1 &amp; 0x3ffffff;
            $d2 += $c;

            /** @var int $c */
            $c = $d2 &gt;&gt; 26;
            /** @var int $h2  */
            $h2 = $d2 &amp; 0x3ffffff;
            $d3 += $c;

            /** @var int $c */
            $c = $d3 &gt;&gt; 26;
            /** @var int $h3 */
            $h3 = $d3 &amp; 0x3ffffff;
            $d4 += $c;

            /** @var int $c */
            $c = $d4 &gt;&gt; 26;
            /** @var int $h4 */
            $h4 = $d4 &amp; 0x3ffffff;
            $h0 += (int) self::mul($c, 5, 3);

            /** @var int $c */
            $c = $h0 &gt;&gt; 26;
            /** @var int $h0 */
            $h0 &amp;= 0x3ffffff;
            $h1 += $c;

            // Chop off the left 32 bytes.
            $message = self::substr(
                $message,
                ParagonIE_Sodium_Core_Poly1305::BLOCK_SIZE
            );
            $bytes -= ParagonIE_Sodium_Core_Poly1305::BLOCK_SIZE;
        }

        $this-&gt;h = array(
            (int) ($h0 &amp; 0xffffffff),
            (int) ($h1 &amp; 0xffffffff),
            (int) ($h2 &amp; 0xffffffff),
            (int) ($h3 &amp; 0xffffffff),
            (int) ($h4 &amp; 0xffffffff)
        );
        return $this;
    }

    /**
     * @internal You should not use this directly from another application
     *
     * @return string
     * @throws TypeError
     */
    public function finish()
    {
        /* process the remaining block */
        if ($this-&gt;leftover) {
            $i = $this-&gt;leftover;
            $this-&gt;buffer[$i++] = 1;
            for (; $i &lt; ParagonIE_Sodium_Core_Poly1305::BLOCK_SIZE; ++$i) {
                $this-&gt;buffer[$i] = 0;
            }
            $this-&gt;final = true;
            $this-&gt;blocks(
                self::substr(
                    self::intArrayToString($this-&gt;buffer),
                    0,
                    ParagonIE_Sodium_Core_Poly1305::BLOCK_SIZE
                ),
                ParagonIE_Sodium_Core_Poly1305::BLOCK_SIZE
            );
        }

        $h0 = (int) $this-&gt;h[0];
        $h1 = (int) $this-&gt;h[1];
        $h2 = (int) $this-&gt;h[2];
        $h3 = (int) $this-&gt;h[3];
        $h4 = (int) $this-&gt;h[4];

        /** @var int $c */
        $c = $h1 &gt;&gt; 26;
        /** @var int $h1 */
        $h1 &amp;= 0x3ffffff;
        /** @var int $h2 */
        $h2 += $c;
        /** @var int $c */
        $c = $h2 &gt;&gt; 26;
        /** @var int $h2 */
        $h2 &amp;= 0x3ffffff;
        $h3 += $c;
        /** @var int $c */
        $c = $h3 &gt;&gt; 26;
        $h3 &amp;= 0x3ffffff;
        $h4 += $c;
        /** @var int $c */
        $c = $h4 &gt;&gt; 26;
        $h4 &amp;= 0x3ffffff;
        /** @var int $h0 */
        $h0 += self::mul($c, 5, 3);
        /** @var int $c */
        $c = $h0 &gt;&gt; 26;
        /** @var int $h0 */
        $h0 &amp;= 0x3ffffff;
        /** @var int $h1 */
        $h1 += $c;

        /* compute h + -p */
        /** @var int $g0 */
        $g0 = $h0 + 5;
        /** @var int $c */
        $c = $g0 &gt;&gt; 26;
        /** @var int $g0 */
        $g0 &amp;= 0x3ffffff;

        /** @var int $g1 */
        $g1 = $h1 + $c;
        /** @var int $c */
        $c = $g1 &gt;&gt; 26;
        $g1 &amp;= 0x3ffffff;

        /** @var int $g2 */
        $g2 = $h2 + $c;
        /** @var int $c */
        $c = $g2 &gt;&gt; 26;
        /** @var int $g2 */
        $g2 &amp;= 0x3ffffff;

        /** @var int $g3 */
        $g3 = $h3 + $c;
        /** @var int $c */
        $c = $g3 &gt;&gt; 26;
        /** @var int $g3 */
        $g3 &amp;= 0x3ffffff;

        /** @var int $g4 */
        $g4 = ($h4 + $c - (1 &lt;&lt; 26)) &amp; 0xffffffff;

        /* select h if h &lt; p, or h + -p if h &gt;= p */
        /** @var int $mask */
        $mask = ($g4 &gt;&gt; 31) - 1;

        $g0 &amp;= $mask;
        $g1 &amp;= $mask;
        $g2 &amp;= $mask;
        $g3 &amp;= $mask;
        $g4 &amp;= $mask;

        /** @var int $mask */
        $mask = ~$mask &amp; 0xffffffff;
        /** @var int $h0 */
        $h0 = ($h0 &amp; $mask) | $g0;
        /** @var int $h1 */
        $h1 = ($h1 &amp; $mask) | $g1;
        /** @var int $h2 */
        $h2 = ($h2 &amp; $mask) | $g2;
        /** @var int $h3 */
        $h3 = ($h3 &amp; $mask) | $g3;
        /** @var int $h4 */
        $h4 = ($h4 &amp; $mask) | $g4;

        /* h = h % (2^128) */
        /** @var int $h0 */
        $h0 = (($h0) | ($h1 &lt;&lt; 26)) &amp; 0xffffffff;
        /** @var int $h1 */
        $h1 = (($h1 &gt;&gt;  6) | ($h2 &lt;&lt; 20)) &amp; 0xffffffff;
        /** @var int $h2 */
        $h2 = (($h2 &gt;&gt; 12) | ($h3 &lt;&lt; 14)) &amp; 0xffffffff;
        /** @var int $h3 */
        $h3 = (($h3 &gt;&gt; 18) | ($h4 &lt;&lt;  8)) &amp; 0xffffffff;

        /* mac = (h + pad) % (2^128) */
        $f = (int) ($h0 + $this-&gt;pad[0]);
        $h0 = (int) $f;
        $f = (int) ($h1 + $this-&gt;pad[1] + ($f &gt;&gt; 32));
        $h1 = (int) $f;
        $f = (int) ($h2 + $this-&gt;pad[2] + ($f &gt;&gt; 32));
        $h2 = (int) $f;
        $f = (int) ($h3 + $this-&gt;pad[3] + ($f &gt;&gt; 32));
        $h3 = (int) $f;

        return self::store32_le($h0 &amp; 0xffffffff) .
            self::store32_le($h1 &amp; 0xffffffff) .
            self::store32_le($h2 &amp; 0xffffffff) .
            self::store32_le($h3 &amp; 0xffffffff);
    }
}
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fwww%2F4xpips.net%2Fwp-includes%2Fsodium_compat%2Fsrc%2FCore%2FPoly1305'>⬅ Back to Directory</a>