WordPress.org

Make WordPress Core

Ticket #47186: 47186-sodium_compat-v1.10.2-fixed.patch

File 47186-sodium_compat-v1.10.2-fixed.patch, 41.6 KB (added by paragoninitiativeenterprises, 15 months ago)
  • wp-includes/sodium_compat/lib/php72compat.php

    IDEA additional info:
    Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
    <+>UTF-8
     
    107107     * @param string $assocData
    108108     * @param string $nonce
    109109     * @param string $key
    110      * @return string
     110     * @return string|bool
    111111     */
    112112    function sodium_crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key)
    113113    {
     
    153153     * @param string $assocData
    154154     * @param string $nonce
    155155     * @param string $key
    156      * @return string
     156     * @return string|bool
    157157     */
    158158    function sodium_crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key)
    159159    {
     
    199199     * @param string $assocData
    200200     * @param string $nonce
    201201     * @param string $key
    202      * @return string
     202     * @return string|bool
    203203     */
    204204    function sodium_crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key)
    205205    {
     
    245245     * @param string $assocData
    246246     * @param string $nonce
    247247     * @param string $key
    248      * @return string
     248     * @return string|bool
    249249     */
    250250    function sodium_crypto_aead_xchacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key)
    251251    {
    252252        try {
    253             return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key);
     253            return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key, true);
    254254        } catch (Error $ex) {
    255255            return false;
    256256        } catch (Exception $ex) {
     
    271271     */
    272272    function sodium_crypto_aead_xchacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key)
    273273    {
    274         return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key);
     274        return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key, true);
    275275    }
    276276}
    277277if (!is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_keygen')) {
     
    952952if (!is_callable('sodium_increment')) {
    953953    /**
    954954     * @see ParagonIE_Sodium_Compat::increment()
    955      * @param &string $string
     955     * @param string $string
    956956     * @return void
    957957     * @throws SodiumException
    958958     * @throws TypeError
     
    10091009if (!is_callable('sodium_memzero')) {
    10101010    /**
    10111011     * @see ParagonIE_Sodium_Compat::memzero()
    1012      * @param string &$str
     1012     * @param string $str
    10131013     * @return void
    10141014     * @throws SodiumException
    10151015     * @throws TypeError
  • wp-includes/sodium_compat/src/Core/Curve25519/Fe.php

    IDEA additional info:
    Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
    <+>UTF-8
     
    1212class ParagonIE_Sodium_Core_Curve25519_Fe implements ArrayAccess
    1313{
    1414    /**
    15      * @var array
     15     * @var array<int, int>
    1616     */
    1717    protected $container = array();
    1818
     
    2424    /**
    2525     * @internal You should not use this directly from another application
    2626     *
    27      * @param array $array
     27     * @param array<int, int> $array
    2828     * @param bool $save_indexes
    2929     * @return self
    3030     */
     
    3737            $keys = range(0, $count - 1);
    3838        }
    3939        $array = array_values($array);
     40        /** @var array<int, int> $keys */
    4041
    4142        $obj = new ParagonIE_Sodium_Core_Curve25519_Fe();
    4243        if ($save_indexes) {
     
    5455    /**
    5556     * @internal You should not use this directly from another application
    5657     *
    57      * @param mixed $offset
    58      * @param mixed $value
     58     * @param int|null $offset
     59     * @param int $value
    5960     * @return void
    6061     * @psalm-suppress MixedArrayOffset
    6162     */
     
    7475    /**
    7576     * @internal You should not use this directly from another application
    7677     *
    77      * @param mixed $offset
     78     * @param int $offset
    7879     * @return bool
    7980     * @psalm-suppress MixedArrayOffset
    8081     */
     
    8687    /**
    8788     * @internal You should not use this directly from another application
    8889     *
    89      * @param mixed $offset
     90     * @param int $offset
    9091     * @return void
    9192     * @psalm-suppress MixedArrayOffset
    9293     */
     
    9899    /**
    99100     * @internal You should not use this directly from another application
    100101     *
    101      * @param mixed $offset
    102      * @return mixed|null
     102     * @param int $offset
     103     * @return int
    103104     * @psalm-suppress MixedArrayOffset
    104105     */
    105106    public function offsetGet($offset)
    106107    {
    107         return isset($this->container[$offset])
    108             ? $this->container[$offset]
    109             : null;
     108        if (!isset($this->container[$offset])) {
     109            $this->container[$offset] = 0;
     110        }
     111        return (int) ($this->container[$offset]);
    110112    }
    111113
    112114    /**
  • wp-includes/sodium_compat/src/Core32/Int32.php

    IDEA additional info:
    Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
    <+>UTF-8
     
    150150        );
    151151    }
    152152
     153    /**
     154     * @param array<int, int> $a
     155     * @param array<int, int> $b
     156     * @param int $baseLog2
     157     * @return array<int, int>
     158     */
     159    public function multiplyLong(array $a, array $b, $baseLog2 = 16)
     160    {
     161        $a_l = count($a);
     162        $b_l = count($b);
     163        /** @var array<int, int> $r */
     164        $r = array_fill(0, $a_l + $b_l + 1, 0);
     165        $base = 1 << $baseLog2;
     166        for ($i = 0; $i < $a_l; ++$i) {
     167            $a_i = $a[$i];
     168            for ($j = 0; $j < $a_l; ++$j) {
     169                $b_j = $b[$j];
     170                $product = ($a_i * $b_j) + $r[$i + $j];
     171                $carry = ($product >> $baseLog2 & 0xffff);
     172                $r[$i + $j] = ($product - (int) ($carry * $base)) & 0xffff;
     173                $r[$i + $j + 1] += $carry;
     174            }
     175        }
     176        return array_slice($r, 0, 5);
     177    }
     178
     179    /**
     180     * @param int $int
     181     * @return ParagonIE_Sodium_Core32_Int32
     182     */
     183    public function mulIntFast($int)
     184    {
     185        // Handle negative numbers
     186        $aNeg = ($this->limbs[0] >> 15) & 1;
     187        $bNeg = ($int >> 31) & 1;
     188        $a = array_reverse($this->limbs);
     189        $b = array(
     190            $int & 0xffff,
     191            ($int >> 16) & 0xffff
     192        );
     193        if ($aNeg) {
     194            for ($i = 0; $i < 2; ++$i) {
     195                $a[$i] = ($a[$i] ^ 0xffff) & 0xffff;
     196            }
     197            ++$a[0];
     198        }
     199        if ($bNeg) {
     200            for ($i = 0; $i < 2; ++$i) {
     201                $b[$i] = ($b[$i] ^ 0xffff) & 0xffff;
     202            }
     203            ++$b[0];
     204        }
     205        // Multiply
     206        $res = $this->multiplyLong($a, $b);
     207
     208        // Re-apply negation to results
     209        if ($aNeg !== $bNeg) {
     210            for ($i = 0; $i < 2; ++$i) {
     211                $res[$i] = (0xffff ^ $res[$i]) & 0xffff;
     212            }
     213            // Handle integer overflow
     214            $c = 1;
     215            for ($i = 0; $i < 2; ++$i) {
     216                $res[$i] += $c;
     217                $c = $res[$i] >> 16;
     218                $res[$i] &= 0xffff;
     219            }
     220        }
     221
     222        // Return our values
     223        $return = new ParagonIE_Sodium_Core32_Int32();
     224        $return->limbs = array(
     225            $res[1] & 0xffff,
     226            $res[0] & 0xffff
     227        );
     228        if (count($res) > 2) {
     229            $return->overflow = $res[2] & 0xffff;
     230        }
     231        $return->unsignedInt = $this->unsignedInt;
     232        return $return;
     233    }
     234
     235    /**
     236     * @param ParagonIE_Sodium_Core32_Int32 $right
     237     * @return ParagonIE_Sodium_Core32_Int32
     238     */
     239    public function mulInt32Fast(ParagonIE_Sodium_Core32_Int32 $right)
     240    {
     241        $aNeg = ($this->limbs[0] >> 15) & 1;
     242        $bNeg = ($right->limbs[0] >> 15) & 1;
     243
     244        $a = array_reverse($this->limbs);
     245        $b = array_reverse($right->limbs);
     246        if ($aNeg) {
     247            for ($i = 0; $i < 2; ++$i) {
     248                $a[$i] = ($a[$i] ^ 0xffff) & 0xffff;
     249            }
     250            ++$a[0];
     251        }
     252        if ($bNeg) {
     253            for ($i = 0; $i < 2; ++$i) {
     254                $b[$i] = ($b[$i] ^ 0xffff) & 0xffff;
     255            }
     256            ++$b[0];
     257        }
     258        $res = $this->multiplyLong($a, $b);
     259        if ($aNeg !== $bNeg) {
     260            if ($aNeg !== $bNeg) {
     261                for ($i = 0; $i < 2; ++$i) {
     262                    $res[$i] = ($res[$i] ^ 0xffff) & 0xffff;
     263                }
     264                $c = 1;
     265                for ($i = 0; $i < 2; ++$i) {
     266                    $res[$i] += $c;
     267                    $c = $res[$i] >> 16;
     268                    $res[$i] &= 0xffff;
     269                }
     270            }
     271        }
     272        $return = new ParagonIE_Sodium_Core32_Int32();
     273        $return->limbs = array(
     274            $res[1] & 0xffff,
     275            $res[0] & 0xffff
     276        );
     277        if (count($res) > 2) {
     278            $return->overflow = $res[2];
     279        }
     280        return $return;
     281    }
     282
    153283    /**
    154284     * @param int $int
    155285     * @param int $size
     
    161291    {
    162292        ParagonIE_Sodium_Core32_Util::declareScalarType($int, 'int', 1);
    163293        ParagonIE_Sodium_Core32_Util::declareScalarType($size, 'int', 2);
     294        if (ParagonIE_Sodium_Compat::$fastMult) {
     295            return $this->mulIntFast((int) $int);
     296        }
    164297        /** @var int $int */
    165298        $int = (int) $int;
    166299        /** @var int $size */
     
    218351    public function mulInt32(ParagonIE_Sodium_Core32_Int32 $int, $size = 0)
    219352    {
    220353        ParagonIE_Sodium_Core32_Util::declareScalarType($size, 'int', 2);
     354        if (ParagonIE_Sodium_Compat::$fastMult) {
     355            return $this->mulInt32Fast($int);
     356        }
    221357        if (!$size) {
    222358            $size = 31;
    223359        }
     
    491627            /** @var int $c */
    492628            return $this->shiftLeft(-$c);
    493629        } else {
    494             if (is_null($c)) {
     630            if (!is_int($c)) {
    495631                throw new TypeError();
    496632            }
    497633            /** @var int $c */
  • wp-includes/sodium_compat/src/Core/ChaCha20/Ctx.php

    IDEA additional info:
    Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
    <+>UTF-8
     
    8383    /**
    8484     * @internal You should not use this directly from another application
    8585     *
    86      * @param mixed $offset
     86     * @param int $offset
    8787     * @return bool
    88      * @psalm-suppress MixedArrayOffset
    8988     */
    9089    public function offsetExists($offset)
    9190    {
     
    9594    /**
    9695     * @internal You should not use this directly from another application
    9796     *
    98      * @param mixed $offset
     97     * @param int $offset
    9998     * @return void
    10099     * @psalm-suppress MixedArrayOffset
    101100     */
     
    107106    /**
    108107     * @internal You should not use this directly from another application
    109108     *
    110      * @param mixed $offset
     109     * @param int $offset
    111110     * @return mixed|null
    112111     * @psalm-suppress MixedArrayOffset
    113112     */
  • wp-includes/sodium_compat/src/Core32/Int64.php

    IDEA additional info:
    Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
    <+>UTF-8
     
    205205     */
    206206    public function mulInt($int = 0, $size = 0)
    207207    {
     208        if (ParagonIE_Sodium_Compat::$fastMult) {
     209            return $this->mulIntFast($int);
     210        }
    208211        ParagonIE_Sodium_Core32_Util::declareScalarType($int, 'int', 1);
    209212        ParagonIE_Sodium_Core32_Util::declareScalarType($size, 'int', 2);
    210213        /** @var int $int */
     
    268271            $a3 &= 0xffff;
    269272
    270273            $int >>= 1;
    271             $return->limbs[0] = $ret0;
    272             $return->limbs[1] = $ret1;
    273             $return->limbs[2] = $ret2;
    274             $return->limbs[3] = $ret3;
    275         }
     274        }
     275        $return->limbs[0] = $ret0;
     276        $return->limbs[1] = $ret1;
     277        $return->limbs[2] = $ret2;
     278        $return->limbs[3] = $ret3;
    276279        return $return;
    277280    }
    278281
     
    317320        );
    318321    }
    319322
     323    /**
     324     * @param array<int, int> $a
     325     * @param array<int, int> $b
     326     * @param int $baseLog2
     327     * @return array<int, int>
     328     */
     329    public function multiplyLong(array $a, array $b, $baseLog2 = 16)
     330    {
     331        $a_l = count($a);
     332        $b_l = count($b);
     333        /** @var array<int, int> $r */
     334        $r = array_fill(0, $a_l + $b_l + 1, 0);
     335        $base = 1 << $baseLog2;
     336        for ($i = 0; $i < $a_l; ++$i) {
     337            $a_i = $a[$i];
     338            for ($j = 0; $j < $a_l; ++$j) {
     339                $b_j = $b[$j];
     340                $product = ($a_i * $b_j) + $r[$i + $j];
     341                $carry = ($product >> $baseLog2 & 0xffff);
     342                $r[$i + $j] = ($product - (int) ($carry * $base)) & 0xffff;
     343                $r[$i + $j + 1] += $carry;
     344            }
     345        }
     346        return array_slice($r, 0, 5);
     347    }
     348
     349    /**
     350     * @param int $int
     351     * @return ParagonIE_Sodium_Core32_Int64
     352     */
     353    public function mulIntFast($int)
     354    {
     355        // Handle negative numbers
     356        $aNeg = ($this->limbs[0] >> 15) & 1;
     357        $bNeg = ($int >> 31) & 1;
     358        $a = array_reverse($this->limbs);
     359        $b = array(
     360            $int & 0xffff,
     361            ($int >> 16) & 0xffff,
     362            -$bNeg & 0xffff,
     363            -$bNeg & 0xffff
     364        );
     365        if ($aNeg) {
     366            for ($i = 0; $i < 4; ++$i) {
     367                $a[$i] = ($a[$i] ^ 0xffff) & 0xffff;
     368            }
     369            ++$a[0];
     370        }
     371        if ($bNeg) {
     372            for ($i = 0; $i < 4; ++$i) {
     373                $b[$i] = ($b[$i] ^ 0xffff) & 0xffff;
     374            }
     375            ++$b[0];
     376        }
     377        // Multiply
     378        $res = $this->multiplyLong($a, $b);
     379
     380        // Re-apply negation to results
     381        if ($aNeg !== $bNeg) {
     382            for ($i = 0; $i < 4; ++$i) {
     383                $res[$i] = (0xffff ^ $res[$i]) & 0xffff;
     384            }
     385            // Handle integer overflow
     386            $c = 1;
     387            for ($i = 0; $i < 4; ++$i) {
     388                $res[$i] += $c;
     389                $c = $res[$i] >> 16;
     390                $res[$i] &= 0xffff;
     391            }
     392        }
     393
     394        // Return our values
     395        $return = new ParagonIE_Sodium_Core32_Int64();
     396        $return->limbs = array(
     397            $res[3] & 0xffff,
     398            $res[2] & 0xffff,
     399            $res[1] & 0xffff,
     400            $res[0] & 0xffff
     401        );
     402        if (count($res) > 4) {
     403            $return->overflow = $res[4] & 0xffff;
     404        }
     405        $return->unsignedInt = $this->unsignedInt;
     406        return $return;
     407    }
     408
     409    /**
     410     * @param ParagonIE_Sodium_Core32_Int64 $right
     411     * @return ParagonIE_Sodium_Core32_Int64
     412     */
     413    public function mulInt64Fast(ParagonIE_Sodium_Core32_Int64 $right)
     414    {
     415        $aNeg = ($this->limbs[0] >> 15) & 1;
     416        $bNeg = ($right->limbs[0] >> 15) & 1;
     417
     418        $a = array_reverse($this->limbs);
     419        $b = array_reverse($right->limbs);
     420        if ($aNeg) {
     421            for ($i = 0; $i < 4; ++$i) {
     422                $a[$i] = ($a[$i] ^ 0xffff) & 0xffff;
     423            }
     424            ++$a[0];
     425        }
     426        if ($bNeg) {
     427            for ($i = 0; $i < 4; ++$i) {
     428                $b[$i] = ($b[$i] ^ 0xffff) & 0xffff;
     429            }
     430            ++$b[0];
     431        }
     432        $res = $this->multiplyLong($a, $b);
     433        if ($aNeg !== $bNeg) {
     434            if ($aNeg !== $bNeg) {
     435                for ($i = 0; $i < 4; ++$i) {
     436                    $res[$i] = ($res[$i] ^ 0xffff) & 0xffff;
     437                }
     438                $c = 1;
     439                for ($i = 0; $i < 4; ++$i) {
     440                    $res[$i] += $c;
     441                    $c = $res[$i] >> 16;
     442                    $res[$i] &= 0xffff;
     443                }
     444            }
     445        }
     446        $return = new ParagonIE_Sodium_Core32_Int64();
     447        $return->limbs = array(
     448            $res[3] & 0xffff,
     449            $res[2] & 0xffff,
     450            $res[1] & 0xffff,
     451            $res[0] & 0xffff
     452        );
     453        if (count($res) > 4) {
     454            $return->overflow = $res[4];
     455        }
     456        return $return;
     457    }
     458
    320459    /**
    321460     * @param ParagonIE_Sodium_Core32_Int64 $int
    322461     * @param int $size
     
    327466     */
    328467    public function mulInt64(ParagonIE_Sodium_Core32_Int64 $int, $size = 0)
    329468    {
     469        if (ParagonIE_Sodium_Compat::$fastMult) {
     470            return $this->mulInt64Fast($int);
     471        }
    330472        ParagonIE_Sodium_Core32_Util::declareScalarType($size, 'int', 2);
    331473        if (!$size) {
    332474            $size = 63;
     
    566708            /** @var int $c */
    567709            return $this->shiftRight(-$c);
    568710        } else {
    569             if (is_null($c)) {
     711            if (!is_int($c)) {
    570712                throw new TypeError();
    571713            }
    572714            /** @var int $carry */
     
    591733    public function shiftRight($c = 0)
    592734    {
    593735        ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);
     736        $c = (int) $c;
     737        /** @var int $c */
    594738        $return = new ParagonIE_Sodium_Core32_Int64();
    595739        $return->unsignedInt = $this->unsignedInt;
    596740        $c &= 63;
    597         /** @var int $c */
    598741
    599742        $negative = -(($this->limbs[0] >> 15) & 1);
    600743        if ($c >= 16) {
  • wp-includes/sodium_compat/src/Core/BLAKE2b.php

    IDEA additional info:
    Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
    <+>UTF-8
     
    256256            if (++$i > $maxLength) {
    257257                return;
    258258            }
     259            /** @psalm-suppress MixedOperand */
    259260            $u[$uIdx] >>= 8;
    260261        }
    261262    }
     
    642643    /**
    643644     * @internal You should not use this directly from another application
    644645     *
    645      * @param SplFixedArray[SplFixedArray] $ctx
     646     * @param SplFixedArray $ctx
    646647     * @return string
    647648     * @throws TypeError
    648649     * @psalm-suppress MixedArgument
  • wp-includes/sodium_compat/namespaced/Core/Xsalsa20.php

    IDEA additional info:
    Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
    <+>UTF-8
     
    11<?php
    22namespace ParagonIE\Sodium\Core;
    33
    4 class Xsalsa20 extends \ParagonIE_Sodium_Core_Xsalsa20
     4class Xsalsa20 extends \ParagonIE_Sodium_Core_XSalsa20
    55{
    66
    77}
  • wp-includes/sodium_compat/src/Core/Util.php

    IDEA additional info:
    Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
    <+>UTF-8
     
    817817        } else {
    818818            $sub = (string) substr($str, $start, $length);
    819819        }
    820         if (isset($sub)) {
     820        if ($sub !== '') {
    821821            return $sub;
    822822        }
    823823        return '';
  • wp-includes/sodium_compat/src/Core32/ChaCha20/Ctx.php

    IDEA additional info:
    Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
    <+>UTF-8
     
    8989    /**
    9090     * @internal You should not use this directly from another application
    9191     *
    92      * @param mixed $offset
     92     * @param int $offset
    9393     * @return bool
    9494     * @psalm-suppress MixedArrayOffset
    9595     */
     
    101101    /**
    102102     * @internal You should not use this directly from another application
    103103     *
    104      * @param mixed $offset
     104     * @param int $offset
    105105     * @return void
    106106     * @psalm-suppress MixedArrayOffset
    107107     */
     
    113113    /**
    114114     * @internal You should not use this directly from another application
    115115     *
    116      * @param mixed $offset
     116     * @param int $offset
    117117     * @return mixed|null
    118118     * @psalm-suppress MixedArrayOffset
    119119     */
  • wp-includes/sodium_compat/src/Core32/BLAKE2b.php

    IDEA additional info:
    Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
    <+>UTF-8
     
    574574    /**
    575575     * @internal You should not use this directly from another application
    576576     *
    577      * @param SplFixedArray[SplFixedArray] $ctx
     577     * @param SplFixedArray $ctx
    578578     * @return string
    579579     * @throws TypeError
    580580     * @psalm-suppress MixedArgument
  • wp-includes/sodium_compat/src/Crypto.php

    IDEA additional info:
    Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
    <+>UTF-8
     
    819819     */
    820820    public static function keyExchange($my_sk, $their_pk, $client_pk, $server_pk)
    821821    {
    822         return self::generichash(
    823             self::scalarmult($my_sk, $their_pk) .
     822        return ParagonIE_Sodium_Compat::crypto_generichash(
     823            ParagonIE_Sodium_Compat::crypto_scalarmult($my_sk, $their_pk) .
    824824            $client_pk .
    825825            $server_pk
    826826        );
  • wp-includes/sodium_compat/src/Core32/X25519.php

    IDEA additional info:
    Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
    <+>UTF-8
     
    102102     */
    103103    public static function fe_mul121666(ParagonIE_Sodium_Core32_Curve25519_Fe $f)
    104104    {
    105         /** @var array<int, ParagonIE_Sodium_Core32_Int32> $h */
     105        /** @var array<int, ParagonIE_Sodium_Core32_Int64> $h */
    106106        $h = array();
    107107        for ($i = 0; $i < 10; ++$i) {
    108108            $h[$i] = $f[$i]->toInt64()->mulInt(121666, 17);
    109109        }
    110110
    111         /** @var ParagonIE_Sodium_Core32_Int32 $carry9 */
    112111        $carry9 = $h[9]->addInt(1 << 24)->shiftRight(25);
    113112        $h[0] = $h[0]->addInt64($carry9->mulInt(19, 5));
    114113        $h[9] = $h[9]->subInt64($carry9->shiftLeft(25));
    115114
    116         /** @var ParagonIE_Sodium_Core32_Int32 $carry1 */
    117115        $carry1 = $h[1]->addInt(1 << 24)->shiftRight(25);
    118116        $h[2] = $h[2]->addInt64($carry1);
    119117        $h[1] = $h[1]->subInt64($carry1->shiftLeft(25));
    120118
    121         /** @var ParagonIE_Sodium_Core32_Int32 $carry3 */
    122119        $carry3 = $h[3]->addInt(1 << 24)->shiftRight(25);
    123120        $h[4] = $h[4]->addInt64($carry3);
    124121        $h[3] = $h[3]->subInt64($carry3->shiftLeft(25));
    125122
    126         /** @var ParagonIE_Sodium_Core32_Int32 $carry5 */
    127123        $carry5 = $h[5]->addInt(1 << 24)->shiftRight(25);
    128124        $h[6] = $h[6]->addInt64($carry5);
    129125        $h[5] = $h[5]->subInt64($carry5->shiftLeft(25));
    130126
    131         /** @var ParagonIE_Sodium_Core32_Int32 $carry7 */
    132127        $carry7 = $h[7]->addInt(1 << 24)->shiftRight(25);
    133128        $h[8] = $h[8]->addInt64($carry7);
    134129        $h[7] = $h[7]->subInt64($carry7->shiftLeft(25));
    135130
    136         /** @var ParagonIE_Sodium_Core32_Int32 $carry0 */
    137131        $carry0 = $h[0]->addInt(1 << 25)->shiftRight(26);
    138132        $h[1] = $h[1]->addInt64($carry0);
    139133        $h[0] = $h[0]->subInt64($carry0->shiftLeft(26));
    140134
    141         /** @var ParagonIE_Sodium_Core32_Int32 $carry2 */
    142135        $carry2 = $h[2]->addInt(1 << 25)->shiftRight(26);
    143136        $h[3] = $h[3]->addInt64($carry2);
    144137        $h[2] = $h[2]->subInt64($carry2->shiftLeft(26));
    145138
    146         /** @var ParagonIE_Sodium_Core32_Int32 $carry4 */
    147139        $carry4 = $h[4]->addInt(1 << 25)->shiftRight(26);
    148140        $h[5] = $h[5]->addInt64($carry4);
    149141        $h[4] = $h[4]->subInt64($carry4->shiftLeft(26));
    150142
    151         /** @var ParagonIE_Sodium_Core32_Int32 $carry6 */
    152143        $carry6 = $h[6]->addInt(1 << 25)->shiftRight(26);
    153144        $h[7] = $h[7]->addInt64($carry6);
    154145        $h[6] = $h[6]->subInt64($carry6->shiftLeft(26));
    155146
    156         /** @var ParagonIE_Sodium_Core32_Int32 $carry8 */
    157147        $carry8 = $h[8]->addInt(1 << 25)->shiftRight(26);
    158148        $h[9] = $h[9]->addInt64($carry8);
    159149        $h[8] = $h[8]->subInt64($carry8->shiftLeft(26));
  • wp-includes/sodium_compat/namespaced/Core/Salsa20.php

    IDEA additional info:
    Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
    <+>UTF-8
     
    11<?php
    22namespace ParagonIE\Sodium\Core;
    33
    4 class SipHash extends \ParagonIE_Sodium_Core_Salsa20
     4class Salsa20 extends \ParagonIE_Sodium_Core_Salsa20
    55{
    66
    7 }
    8  No newline at end of file
     7}
  • wp-includes/sodium_compat/src/Compat.php

    IDEA additional info:
    Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
    <+>UTF-8
     
    144144     *
    145145     * @param string $left  The left operand; must be a string
    146146     * @param string $right The right operand; must be a string
    147      * @return int          < 0 if the left operand is less than the right
    148      *                      = 0 if both strings are equal
    149      *                      > 0 if the right operand is less than the left
     147     * @return int          If < 0 if the left operand is less than the right
     148     *                      If = 0 if both strings are equal
     149     *                      If > 0 if the right operand is less than the left
    150150     * @throws SodiumException
    151151     * @throws TypeError
    152152     * @psalm-suppress MixedArgument
     
    669669     * This mode uses a 64-bit random nonce with a 64-bit counter.
    670670     * IETF mode uses a 96-bit random nonce with a 32-bit counter.
    671671     *
    672      * @param string $ciphertext Encrypted message (with Poly1305 MAC appended)
    673      * @param string $assocData Authenticated Associated Data (unencrypted)
    674      * @param string $nonce Number to be used only Once; must be 8 bytes
    675      * @param string $key Encryption key
     672     * @param string $ciphertext   Encrypted message (with Poly1305 MAC appended)
     673     * @param string $assocData    Authenticated Associated Data (unencrypted)
     674     * @param string $nonce        Number to be used only Once; must be 8 bytes
     675     * @param string $key          Encryption key
     676     * @param bool   $dontFallback Don't fallback to ext/sodium
    676677     *
    677      * @return string            The original plaintext message
     678     * @return string|bool         The original plaintext message
    678679     * @throws SodiumException
    679680     * @throws TypeError
    680681     * @psalm-suppress MixedArgument
     
    683684        $ciphertext = '',
    684685        $assocData = '',
    685686        $nonce = '',
    686         $key = ''
     687        $key = '',
     688        $dontFallback = false
    687689    ) {
    688690        /* Type checks: */
    689691        ParagonIE_Sodium_Core_Util::declareScalarType($ciphertext, 'string', 1);
     
    701703        if (ParagonIE_Sodium_Core_Util::strlen($ciphertext) < self::CRYPTO_AEAD_XCHACHA20POLY1305_IETF_ABYTES) {
    702704            throw new SodiumException('Message must be at least CRYPTO_AEAD_XCHACHA20POLY1305_IETF_ABYTES long');
    703705        }
     706        if (self::useNewSodiumAPI() && !$dontFallback) {
     707            if (is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_decrypt')) {
     708                return sodium_crypto_aead_xchacha20poly1305_ietf_decrypt(
     709                    $ciphertext,
     710                    $assocData,
     711                    $nonce,
     712                    $key
     713                );
     714            }
     715        }
    704716
    705717        if (PHP_INT_SIZE === 4) {
    706718            return ParagonIE_Sodium_Crypto32::aead_xchacha20poly1305_ietf_decrypt(
     
    727739     * This mode uses a 64-bit random nonce with a 64-bit counter.
    728740     * IETF mode uses a 96-bit random nonce with a 32-bit counter.
    729741     *
    730      * @param string $plaintext Message to be encrypted
    731      * @param string $assocData Authenticated Associated Data (unencrypted)
    732      * @param string $nonce Number to be used only Once; must be 8 bytes
    733      * @param string $key Encryption key
     742     * @param string $plaintext    Message to be encrypted
     743     * @param string $assocData    Authenticated Associated Data (unencrypted)
     744     * @param string $nonce        Number to be used only Once; must be 8 bytes
     745     * @param string $key          Encryption key
     746     * @param bool   $dontFallback Don't fallback to ext/sodium
    734747     *
    735748     * @return string           Ciphertext with a 16-byte Poly1305 message
    736749     *                          authentication code appended
     
    742755        $plaintext = '',
    743756        $assocData = '',
    744757        $nonce = '',
    745         $key = ''
     758        $key = '',
     759        $dontFallback = false
    746760    ) {
    747761        /* Type checks: */
    748762        ParagonIE_Sodium_Core_Util::declareScalarType($plaintext, 'string', 1);
     
    757771        if (ParagonIE_Sodium_Core_Util::strlen($key) !== self::CRYPTO_AEAD_XCHACHA20POLY1305_IETF_KEYBYTES) {
    758772            throw new SodiumException('Key must be CRYPTO_AEAD_XCHACHA20POLY1305_KEYBYTES long');
    759773        }
     774        if (self::useNewSodiumAPI() && !$dontFallback) {
     775            if (is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_encrypt')) {
     776                return sodium_crypto_aead_xchacha20poly1305_ietf_encrypt(
     777                    $plaintext,
     778                    $assocData,
     779                    $nonce,
     780                    $key
     781                );
     782            }
     783        }
    760784
    761785        if (PHP_INT_SIZE === 4) {
    762786            return ParagonIE_Sodium_Crypto32::aead_xchacha20poly1305_ietf_encrypt(
     
    12791303    /**
    12801304     * Get the final BLAKE2b hash output for a given context.
    12811305     *
    1282      * @param string &$ctx BLAKE2 hashing context. Generated by crypto_generichash_init().
    1283      * @param int $length  Hash output size.
    1284      * @return string      Final BLAKE2b hash.
     1306     * @param string $ctx BLAKE2 hashing context. Generated by crypto_generichash_init().
     1307     * @param int $length Hash output size.
     1308     * @return string     Final BLAKE2b hash.
    12851309     * @throws SodiumException
    12861310     * @throws TypeError
    12871311     * @psalm-suppress MixedArgument
     1312     * @psalm-suppress ReferenceConstraintViolation
    12881313     */
    12891314    public static function crypto_generichash_final(&$ctx, $length = self::CRYPTO_GENERICHASH_BYTES)
    12901315    {
     
    13571382    /**
    13581383     * Update a BLAKE2b hashing context with additional data.
    13591384     *
    1360      * @param string &$ctx    BLAKE2 hashing context. Generated by crypto_generichash_init().
    1361      *                        $ctx is passed by reference and gets updated in-place.
     1385     * @param string $ctx    BLAKE2 hashing context. Generated by crypto_generichash_init().
     1386     *                       $ctx is passed by reference and gets updated in-place.
     1387     * @param-out string $ctx
    13621388     * @param string $message The message to append to the existing hash state.
    13631389     * @return void
    13641390     * @throws SodiumException
    13651391     * @throws TypeError
    13661392     * @psalm-suppress MixedArgument
     1393     * @psalm-suppress ReferenceConstraintViolation
    13671394     */
    13681395    public static function crypto_generichash_update(&$ctx, $message)
    13691396    {
     
    26102637     * native library for that.
    26112638     *
    26122639     * @param string|null $var
     2640     * @param-out string|null $var
    26132641     *
    26142642     * @return void
    26152643     * @throws SodiumException (Unless libsodium is installed)
     
    26222650        ParagonIE_Sodium_Core_Util::declareScalarType($var, 'string', 1);
    26232651
    26242652        if (self::useNewSodiumAPI()) {
     2653            /** @psalm-suppress MixedArgument */
    26252654            sodium_memzero($var);
    26262655            return;
    26272656        }
     
    27252754        return random_int(0, 65535);
    27262755    }
    27272756
     2757    /**
     2758     * Runtime testing method for 32-bit platforms.
     2759     *
     2760     * Usage: If runtime_speed_test() returns FALSE, then our 32-bit
     2761     *        implementation is to slow to use safely without risking timeouts.
     2762     *        If this happens, install sodium from PECL to get acceptable
     2763     *        performance.
     2764     *
     2765     * @param int $iterations Number of multiplications to attempt
     2766     * @param int $maxTimeout Milliseconds
     2767     * @return bool           TRUE if we're fast enough, FALSE is not
     2768     * @throws SodiumException
     2769     */
     2770    public static function runtime_speed_test($iterations, $maxTimeout)
     2771    {
     2772        if (self::polyfill_is_fast()) {
     2773            return true;
     2774        }
     2775        /** @var float $end */
     2776        $end = 0.0;
     2777        /** @var float $start */
     2778        $start = microtime(true);
     2779        /** @var ParagonIE_Sodium_Core32_Int64 $a */
     2780        $a = ParagonIE_Sodium_Core32_Int64::fromInt(random_int(3, 1 << 16));
     2781        for ($i = 0; $i < $iterations; ++$i) {
     2782            /** @var ParagonIE_Sodium_Core32_Int64 $b */
     2783            $b = ParagonIE_Sodium_Core32_Int64::fromInt(random_int(3, 1 << 16));
     2784            $a->mulInt64($b);
     2785        }
     2786        /** @var float $end */
     2787        $end = microtime(true);
     2788        /** @var int $diff */
     2789        $diff = (int) ceil(($end - $start) * 1000);
     2790        return $diff < $maxTimeout;
     2791    }
     2792
    27282793    /**
    27292794     * This emulates libsodium's version_string() function, except ours is
    27302795     * prefixed with 'polyfill-'.
  • wp-includes/sodium_compat/lib/sodium_compat.php

    IDEA additional info:
    Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
    <+>UTF-8
     
    4545     * @param string $nonce
    4646     * @param string $key
    4747     * @return string|bool
    48      * @throws \SodiumException
    49      * @throws \TypeError
    5048     */
    5149    function crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key)
    5250    {
    5351        try {
    5452            return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key);
    55         } catch (Error $ex) {
     53        } catch (\TypeError $ex) {
    5654            return false;
    57         } catch (Exception $ex) {
     55        } catch (\SodiumException $ex) {
    5856            return false;
    5957        }
    6058    }
     
    9391     * @param string $nonce
    9492     * @param string $key
    9593     * @return string|bool
    96      * @throws \SodiumException
    97      * @throws \TypeError
    9894     */
    9995    function crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key)
    10096    {
    10197        try {
    10298            return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key);
    103         } catch (Error $ex) {
     99        } catch (\TypeError $ex) {
    104100            return false;
    105         } catch (Exception $ex) {
     101        } catch (\SodiumException $ex) {
    106102            return false;
    107103        }
    108104    }
     
    131127     * @param string $nonce
    132128     * @param string $key
    133129     * @return string|bool
    134      * @throws \SodiumException
    135      * @throws \TypeError
    136130     */
    137131    function crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key)
    138132    {
    139133        try {
    140134            return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key);
    141         } catch (Error $ex) {
     135        } catch (\TypeError $ex) {
    142136            return false;
    143         } catch (Exception $ex) {
     137        } catch (\SodiumException $ex) {
    144138            return false;
    145139        }
    146140    }
     
    238232     * @param string $nonce
    239233     * @param string $kp
    240234     * @return string|bool
    241      * @throws \SodiumException
    242      * @throws \TypeError
    243235     */
    244236    function crypto_box_open($message, $nonce, $kp)
    245237    {
    246238        try {
    247239            return ParagonIE_Sodium_Compat::crypto_box_open($message, $nonce, $kp);
    248         } catch (Error $ex) {
     240        } catch (\TypeError $ex) {
    249241            return false;
    250         } catch (Exception $ex) {
     242        } catch (\SodiumException $ex) {
    251243            return false;
    252244        }
    253245    }
     
    298290     * @param string $message
    299291     * @param string $kp
    300292     * @return string|bool
    301      * @throws \TypeError
    302293     */
    303294    function crypto_box_seal_open($message, $kp)
    304295    {
    305296        try {
    306297            return ParagonIE_Sodium_Compat::crypto_box_seal_open($message, $kp);
    307         } catch (\Error $ex) {
     298        } catch (\TypeError $ex) {
    308299            return false;
    309         } catch (\Exception $ex) {
     300        } catch (\SodiumException $ex) {
    310301            return false;
    311302        }
    312303    }
     
    543534     * @param string $nonce
    544535     * @param string $key
    545536     * @return string|bool
    546      * @throws \SodiumException
    547      * @throws \TypeError
    548537     */
    549538    function crypto_secretbox_open($message, $nonce, $key)
    550539    {
    551540        try {
    552541            return ParagonIE_Sodium_Compat::crypto_secretbox_open($message, $nonce, $key);
    553         } catch (Error $ex) {
     542        } catch (\TypeError $ex) {
    554543            return false;
    555         } catch (Exception $ex) {
     544        } catch (\SodiumException $ex) {
    556545            return false;
    557546        }
    558547    }
     
    622611    {
    623612        try {
    624613            return ParagonIE_Sodium_Compat::crypto_sign_open($signedMessage, $pk);
    625         } catch (\Error $ex) {
     614        } catch (\TypeError $ex) {
    626615            return false;
    627         } catch (\Exception $ex) {
     616        } catch (\SodiumException $ex) {
    628617            return false;
    629618        }
    630619    }
     
    810799     * @see ParagonIE_Sodium_Compat::randombytes_uniform()
    811800     * @param int $upperLimit
    812801     * @return int
    813      * @throws \Exception
     802     * @throws \SodiumException
    814803     * @throws \Error
    815804     */
    816805    function randombytes_uniform($upperLimit)
  • wp-includes/sodium_compat/src/File.php

    IDEA additional info:
    Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
    <+>UTF-8
     
    590590        $az[0] = self::intToChr(self::chrToInt($az[0]) & 248);
    591591        $az[31] = self::intToChr((self::chrToInt($az[31]) & 63) | 64);
    592592
    593         /** @var resource $hs */
    594593        $hs = hash_init('sha512');
    595594        hash_update($hs, self::substr($az, 32, 32));
    596595        /** @var resource $hs */
     
    610609            ParagonIE_Sodium_Core_Ed25519::ge_scalarmult_base($nonce)
    611610        );
    612611
    613         /** @var resource $hs */
    614612        $hs = hash_init('sha512');
    615613        hash_update($hs, self::substr($sig, 0, 32));
    616614        hash_update($hs, self::substr($pk, 0, 32));
     
    719717        /** @var ParagonIE_Sodium_Core_Curve25519_Ge_P3 $A */
    720718        $A = ParagonIE_Sodium_Core_Ed25519::ge_frombytes_negate_vartime($publicKey);
    721719
    722         /** @var resource $hs */
    723720        $hs = hash_init('sha512');
    724721        hash_update($hs, self::substr($sig, 0, 32));
    725722        hash_update($hs, self::substr($publicKey, 0, 32));
     
    10791076     * @param resource|object $hash
    10801077     * @param resource $fp
    10811078     * @param int $size
    1082      * @return mixed (resource on PHP < 7.2, object on PHP >= 7.2)
     1079     * @return resource|object Resource on PHP < 7.2, HashContext object on PHP >= 7.2
    10831080     * @throws SodiumException
    10841081     * @throws TypeError
    10851082     * @psalm-suppress PossiblyInvalidArgument
     
    10951092            if (!is_resource($hash)) {
    10961093                throw new TypeError('Argument 1 must be a resource, ' . gettype($hash) . ' given.');
    10971094            }
    1098 
    10991095        } else {
    11001096            if (!is_object($hash)) {
    11011097                throw new TypeError('Argument 1 must be an object (PHP 7.2+), ' . gettype($hash) . ' given.');
    11021098            }
    11031099        }
     1100
    11041101        if (!is_resource($fp)) {
    11051102            throw new TypeError('Argument 2 must be a resource, ' . gettype($fp) . ' given.');
    11061103        }
     
    11671164        $az[0] = self::intToChr(self::chrToInt($az[0]) & 248);
    11681165        $az[31] = self::intToChr((self::chrToInt($az[31]) & 63) | 64);
    11691166
    1170         /** @var resource $hs */
    11711167        $hs = hash_init('sha512');
    11721168        hash_update($hs, self::substr($az, 32, 32));
    11731169        /** @var resource $hs */
     
    11871183            ParagonIE_Sodium_Core32_Ed25519::ge_scalarmult_base($nonce)
    11881184        );
    11891185
    1190         /** @var resource $hs */
    11911186        $hs = hash_init('sha512');
    11921187        hash_update($hs, self::substr($sig, 0, 32));
    11931188        hash_update($hs, self::substr($pk, 0, 32));
     
    12721267        /** @var ParagonIE_Sodium_Core32_Curve25519_Ge_P3 $A */
    12731268        $A = ParagonIE_Sodium_Core32_Ed25519::ge_frombytes_negate_vartime($publicKey);
    12741269
    1275         /** @var resource $hs */
    12761270        $hs = hash_init('sha512');
    12771271        hash_update($hs, self::substr($sig, 0, 32));
    12781272        hash_update($hs, self::substr($publicKey, 0, 32));