Make WordPress Core

Changeset 54310


Ignore:
Timestamp:
09/26/2022 01:58:53 PM (22 months ago)
Author:
SergeyBiryukov
Message:

Upgrade/Install: Update sodium_compat to v1.19.0.

The latest version of sodium_compat includes improved compatibility with the PHP 8.0 named parameters functionality.

Release notes:
https://github.com/paragonie/sodium_compat/releases/tag/v1.19.0

A full list of changes in this update can be found on GitHub:
https://github.com/paragonie/sodium_compat/compare/v1.18.0...v1.19.0

Follow-up to [49741], [51002], [51591], [52988], [54150].

Props jrf, paragoninitiativeenterprises.
Fixes #56653.

Location:
trunk/src/wp-includes/sodium_compat
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/wp-includes/sodium_compat/LICENSE

    r51002 r54310  
    11ISC License
    22
    3 Copyright (c) 2016-2021, Paragon Initiative Enterprises <security at paragonie dot com>
     3Copyright (c) 2016-2022, Paragon Initiative Enterprises <security at paragonie dot com>
    44Copyright (c) 2013-2019, Frank Denis <j at pureftpd dot org>
    55
  • trunk/src/wp-includes/sodium_compat/lib/php72compat.php

    r51002 r54310  
    111111    /**
    112112     * @see ParagonIE_Sodium_Compat::add()
    113      * @param string $val
    114      * @param string $addv
     113     * @param string $string1
     114     * @param string $string2
    115115     * @return void
    116116     * @throws SodiumException
    117117     */
    118     function sodium_add(&$val, $addv)
    119     {
    120         ParagonIE_Sodium_Compat::add($val, $addv);
     118    function sodium_add(&$string1, $string2)
     119    {
     120        ParagonIE_Sodium_Compat::add($string1, $string2);
    121121    }
    122122}
     
    166166    /**
    167167     * @see ParagonIE_Sodium_Compat::compare()
    168      * @param string $a
    169      * @param string $b
     168     * @param string $string1
     169     * @param string $string2
    170170     * @return int
    171171     * @throws SodiumException
    172172     * @throws TypeError
    173173     */
    174     function sodium_compare($a, $b)
    175     {
    176         return ParagonIE_Sodium_Compat::compare($a, $b);
     174    function sodium_compare($string1, $string2)
     175    {
     176        return ParagonIE_Sodium_Compat::compare($string1, $string2);
    177177    }
    178178}
     
    180180    /**
    181181     * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt()
    182      * @param string $message
    183      * @param string $assocData
     182     * @param string $ciphertext
     183     * @param string $additional_data
    184184     * @param string $nonce
    185185     * @param string $key
    186186     * @return string|bool
    187187     */
    188     function sodium_crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key)
     188    function sodium_crypto_aead_aes256gcm_decrypt($ciphertext, $additional_data, $nonce, $key)
    189189    {
    190190        try {
    191             return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key);
     191            return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt(
     192                $ciphertext,
     193                $additional_data,
     194                $nonce,
     195                $key
     196            );
     197        } catch (Error $ex) {
     198            return false;
     199        } catch (Exception $ex) {
     200            if (($ex instanceof SodiumException) && ($ex->getMessage() === 'AES-256-GCM is not available')) {
     201                throw $ex;
     202            }
     203            return false;
     204        }
     205    }
     206}
     207if (!is_callable('sodium_crypto_aead_aes256gcm_encrypt')) {
     208    /**
     209     * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt()
     210     * @param string $message
     211     * @param string $additional_data
     212     * @param string $nonce
     213     * @param string $key
     214     * @return string
     215     * @throws SodiumException
     216     * @throws TypeError
     217     */
     218    function sodium_crypto_aead_aes256gcm_encrypt($message, $additional_data, $nonce, $key)
     219    {
     220        return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt($message, $additional_data, $nonce, $key);
     221    }
     222}
     223if (!is_callable('sodium_crypto_aead_aes256gcm_is_available')) {
     224    /**
     225     * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_is_available()
     226     * @return bool
     227     */
     228    function sodium_crypto_aead_aes256gcm_is_available()
     229    {
     230        return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_is_available();
     231    }
     232}
     233if (!is_callable('sodium_crypto_aead_chacha20poly1305_decrypt')) {
     234    /**
     235     * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt()
     236     * @param string $ciphertext
     237     * @param string $additional_data
     238     * @param string $nonce
     239     * @param string $key
     240     * @return string|bool
     241     */
     242    function sodium_crypto_aead_chacha20poly1305_decrypt($ciphertext, $additional_data, $nonce, $key)
     243    {
     244        try {
     245            return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt(
     246                $ciphertext,
     247                $additional_data,
     248                $nonce,
     249                $key
     250            );
    192251        } catch (Error $ex) {
    193252            return false;
     
    197256    }
    198257}
    199 if (!is_callable('sodium_crypto_aead_aes256gcm_encrypt')) {
    200     /**
    201      * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt()
    202      * @param string $message
    203      * @param string $assocData
     258if (!is_callable('sodium_crypto_aead_chacha20poly1305_encrypt')) {
     259    /**
     260     * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt()
     261     * @param string $message
     262     * @param string $additional_data
    204263     * @param string $nonce
    205264     * @param string $key
     
    208267     * @throws TypeError
    209268     */
    210     function sodium_crypto_aead_aes256gcm_encrypt($message, $assocData, $nonce, $key)
    211     {
    212         return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt($message, $assocData, $nonce, $key);
    213     }
    214 }
    215 if (!is_callable('sodium_crypto_aead_aes256gcm_is_available')) {
    216     /**
    217      * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_is_available()
    218      * @return bool
    219      */
    220     function sodium_crypto_aead_aes256gcm_is_available()
    221     {
    222         return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_is_available();
    223     }
    224 }
    225 if (!is_callable('sodium_crypto_aead_chacha20poly1305_decrypt')) {
    226     /**
    227      * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt()
    228      * @param string $message
    229      * @param string $assocData
     269    function sodium_crypto_aead_chacha20poly1305_encrypt($message, $additional_data, $nonce, $key)
     270    {
     271        return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt(
     272            $message,
     273            $additional_data,
     274            $nonce,
     275            $key
     276        );
     277    }
     278}
     279if (!is_callable('sodium_crypto_aead_chacha20poly1305_keygen')) {
     280    /**
     281     * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_keygen()
     282     * @return string
     283     * @throws Exception
     284     */
     285    function sodium_crypto_aead_chacha20poly1305_keygen()
     286    {
     287        return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_keygen();
     288    }
     289}
     290if (!is_callable('sodium_crypto_aead_chacha20poly1305_ietf_decrypt')) {
     291    /**
     292     * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt()
     293     * @param string $message
     294     * @param string $additional_data
    230295     * @param string $nonce
    231296     * @param string $key
    232297     * @return string|bool
    233298     */
    234     function sodium_crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key)
     299    function sodium_crypto_aead_chacha20poly1305_ietf_decrypt($message, $additional_data, $nonce, $key)
    235300    {
    236301        try {
    237             return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key);
     302            return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt(
     303                $message,
     304                $additional_data,
     305                $nonce,
     306                $key
     307            );
    238308        } catch (Error $ex) {
    239309            return false;
     
    243313    }
    244314}
    245 if (!is_callable('sodium_crypto_aead_chacha20poly1305_encrypt')) {
    246     /**
    247      * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt()
    248      * @param string $message
    249      * @param string $assocData
     315if (!is_callable('sodium_crypto_aead_chacha20poly1305_ietf_encrypt')) {
     316    /**
     317     * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt()
     318     * @param string $message
     319     * @param string $additional_data
    250320     * @param string $nonce
    251321     * @param string $key
     
    254324     * @throws TypeError
    255325     */
    256     function sodium_crypto_aead_chacha20poly1305_encrypt($message, $assocData, $nonce, $key)
    257     {
    258         return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt($message, $assocData, $nonce, $key);
    259     }
    260 }
    261 if (!is_callable('sodium_crypto_aead_chacha20poly1305_keygen')) {
    262     /**
    263      * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_keygen()
    264      * @return string
    265      * @throws Exception
    266      */
    267     function sodium_crypto_aead_chacha20poly1305_keygen()
    268     {
    269         return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_keygen();
    270     }
    271 }
    272 if (!is_callable('sodium_crypto_aead_chacha20poly1305_ietf_decrypt')) {
    273     /**
    274      * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt()
    275      * @param string $message
    276      * @param string $assocData
     326    function sodium_crypto_aead_chacha20poly1305_ietf_encrypt($message, $additional_data, $nonce, $key)
     327    {
     328        return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt(
     329            $message,
     330            $additional_data,
     331            $nonce,
     332            $key
     333        );
     334    }
     335}
     336if (!is_callable('sodium_crypto_aead_chacha20poly1305_ietf_keygen')) {
     337    /**
     338     * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_keygen()
     339     * @return string
     340     * @throws Exception
     341     */
     342    function sodium_crypto_aead_chacha20poly1305_ietf_keygen()
     343    {
     344        return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_keygen();
     345    }
     346}
     347if (!is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_decrypt')) {
     348    /**
     349     * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_decrypt()
     350     * @param string $ciphertext
     351     * @param string $additional_data
    277352     * @param string $nonce
    278353     * @param string $key
    279354     * @return string|bool
    280355     */
    281     function sodium_crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key)
     356    function sodium_crypto_aead_xchacha20poly1305_ietf_decrypt($ciphertext, $additional_data, $nonce, $key)
    282357    {
    283358        try {
    284             return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key);
     359            return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_decrypt(
     360                $ciphertext,
     361                $additional_data,
     362                $nonce,
     363                $key,
     364                true
     365            );
    285366        } catch (Error $ex) {
    286367            return false;
     
    290371    }
    291372}
    292 if (!is_callable('sodium_crypto_aead_chacha20poly1305_ietf_encrypt')) {
    293     /**
    294      * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt()
    295      * @param string $message
    296      * @param string $assocData
     373if (!is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_encrypt')) {
     374    /**
     375     * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_encrypt()
     376     * @param string $message
     377     * @param string $additional_data
    297378     * @param string $nonce
    298379     * @param string $key
     
    301382     * @throws TypeError
    302383     */
    303     function sodium_crypto_aead_chacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key)
    304     {
    305         return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key);
    306     }
    307 }
    308 if (!is_callable('sodium_crypto_aead_chacha20poly1305_ietf_keygen')) {
    309     /**
    310      * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_keygen()
    311      * @return string
    312      * @throws Exception
    313      */
    314     function sodium_crypto_aead_chacha20poly1305_ietf_keygen()
    315     {
    316         return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_keygen();
    317     }
    318 }
    319 if (!is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_decrypt')) {
    320     /**
    321      * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_decrypt()
    322      * @param string $message
    323      * @param string $assocData
     384    function sodium_crypto_aead_xchacha20poly1305_ietf_encrypt(
     385        $message,
     386        $additional_data,
     387        $nonce,
     388        $key
     389    ) {
     390        return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_encrypt(
     391            $message,
     392            $additional_data,
     393            $nonce,
     394            $key,
     395            true
     396        );
     397    }
     398}
     399if (!is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_keygen')) {
     400    /**
     401     * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_keygen()
     402     * @return string
     403     * @throws Exception
     404     */
     405    function sodium_crypto_aead_xchacha20poly1305_ietf_keygen()
     406    {
     407        return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_keygen();
     408    }
     409}
     410if (!is_callable('sodium_crypto_auth')) {
     411    /**
     412     * @see ParagonIE_Sodium_Compat::crypto_auth()
     413     * @param string $message
     414     * @param string $key
     415     * @return string
     416     * @throws SodiumException
     417     * @throws TypeError
     418     */
     419    function sodium_crypto_auth($message, $key)
     420    {
     421        return ParagonIE_Sodium_Compat::crypto_auth($message, $key);
     422    }
     423}
     424if (!is_callable('sodium_crypto_auth_keygen')) {
     425    /**
     426     * @see ParagonIE_Sodium_Compat::crypto_auth_keygen()
     427     * @return string
     428     * @throws Exception
     429     */
     430    function sodium_crypto_auth_keygen()
     431    {
     432        return ParagonIE_Sodium_Compat::crypto_auth_keygen();
     433    }
     434}
     435if (!is_callable('sodium_crypto_auth_verify')) {
     436    /**
     437     * @see ParagonIE_Sodium_Compat::crypto_auth_verify()
     438     * @param string $mac
     439     * @param string $message
     440     * @param string $key
     441     * @return bool
     442     * @throws SodiumException
     443     * @throws TypeError
     444     */
     445    function sodium_crypto_auth_verify($mac, $message, $key)
     446    {
     447        return ParagonIE_Sodium_Compat::crypto_auth_verify($mac, $message, $key);
     448    }
     449}
     450if (!is_callable('sodium_crypto_box')) {
     451    /**
     452     * @see ParagonIE_Sodium_Compat::crypto_box()
     453     * @param string $message
    324454     * @param string $nonce
    325      * @param string $key
     455     * @param string $key_pair
     456     * @return string
     457     * @throws SodiumException
     458     * @throws TypeError
     459     */
     460    function sodium_crypto_box($message, $nonce, $key_pair)
     461    {
     462        return ParagonIE_Sodium_Compat::crypto_box($message, $nonce, $key_pair);
     463    }
     464}
     465if (!is_callable('sodium_crypto_box_keypair')) {
     466    /**
     467     * @see ParagonIE_Sodium_Compat::crypto_box_keypair()
     468     * @return string
     469     * @throws SodiumException
     470     * @throws TypeError
     471     */
     472    function sodium_crypto_box_keypair()
     473    {
     474        return ParagonIE_Sodium_Compat::crypto_box_keypair();
     475    }
     476}
     477if (!is_callable('sodium_crypto_box_keypair_from_secretkey_and_publickey')) {
     478    /**
     479     * @see ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey()
     480     * @param string $secret_key
     481     * @param string $public_key
     482     * @return string
     483     * @throws SodiumException
     484     * @throws TypeError
     485     */
     486    function sodium_crypto_box_keypair_from_secretkey_and_publickey($secret_key, $public_key)
     487    {
     488        return ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey($secret_key, $public_key);
     489    }
     490}
     491if (!is_callable('sodium_crypto_box_open')) {
     492    /**
     493     * @see ParagonIE_Sodium_Compat::crypto_box_open()
     494     * @param string $ciphertext
     495     * @param string $nonce
     496     * @param string $key_pair
    326497     * @return string|bool
    327498     */
    328     function sodium_crypto_aead_xchacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key)
     499    function sodium_crypto_box_open($ciphertext, $nonce, $key_pair)
    329500    {
    330501        try {
    331             return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key, true);
     502            return ParagonIE_Sodium_Compat::crypto_box_open($ciphertext, $nonce, $key_pair);
    332503        } catch (Error $ex) {
    333504            return false;
     
    337508    }
    338509}
    339 if (!is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_encrypt')) {
    340     /**
    341      * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_encrypt()
    342      * @param string $message
    343      * @param string $assocData
    344      * @param string $nonce
    345      * @param string $key
    346      * @return string
    347      * @throws SodiumException
    348      * @throws TypeError
    349      */
    350     function sodium_crypto_aead_xchacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key)
    351     {
    352         return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key, true);
    353     }
    354 }
    355 if (!is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_keygen')) {
    356     /**
    357      * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_keygen()
    358      * @return string
    359      * @throws Exception
    360      */
    361     function sodium_crypto_aead_xchacha20poly1305_ietf_keygen()
    362     {
    363         return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_keygen();
    364     }
    365 }
    366 if (!is_callable('sodium_crypto_auth')) {
    367     /**
    368      * @see ParagonIE_Sodium_Compat::crypto_auth()
    369      * @param string $message
    370      * @param string $key
    371      * @return string
    372      * @throws SodiumException
    373      * @throws TypeError
    374      */
    375     function sodium_crypto_auth($message, $key)
    376     {
    377         return ParagonIE_Sodium_Compat::crypto_auth($message, $key);
    378     }
    379 }
    380 if (!is_callable('sodium_crypto_auth_keygen')) {
    381     /**
    382      * @see ParagonIE_Sodium_Compat::crypto_auth_keygen()
    383      * @return string
    384      * @throws Exception
    385      */
    386     function sodium_crypto_auth_keygen()
    387     {
    388         return ParagonIE_Sodium_Compat::crypto_auth_keygen();
    389     }
    390 }
    391 if (!is_callable('sodium_crypto_auth_verify')) {
    392     /**
    393      * @see ParagonIE_Sodium_Compat::crypto_auth_verify()
    394      * @param string $mac
    395      * @param string $message
    396      * @param string $key
    397      * @return bool
    398      * @throws SodiumException
    399      * @throws TypeError
    400      */
    401     function sodium_crypto_auth_verify($mac, $message, $key)
    402     {
    403         return ParagonIE_Sodium_Compat::crypto_auth_verify($mac, $message, $key);
    404     }
    405 }
    406 if (!is_callable('sodium_crypto_box')) {
    407     /**
    408      * @see ParagonIE_Sodium_Compat::crypto_box()
    409      * @param string $message
    410      * @param string $nonce
    411      * @param string $kp
    412      * @return string
    413      * @throws SodiumException
    414      * @throws TypeError
    415      */
    416     function sodium_crypto_box($message, $nonce, $kp)
    417     {
    418         return ParagonIE_Sodium_Compat::crypto_box($message, $nonce, $kp);
    419     }
    420 }
    421 if (!is_callable('sodium_crypto_box_keypair')) {
    422     /**
    423      * @see ParagonIE_Sodium_Compat::crypto_box_keypair()
    424      * @return string
    425      * @throws SodiumException
    426      * @throws TypeError
    427      */
    428     function sodium_crypto_box_keypair()
    429     {
    430         return ParagonIE_Sodium_Compat::crypto_box_keypair();
    431     }
    432 }
    433 if (!is_callable('sodium_crypto_box_keypair_from_secretkey_and_publickey')) {
    434     /**
    435      * @see ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey()
    436      * @param string $sk
    437      * @param string $pk
    438      * @return string
    439      * @throws SodiumException
    440      * @throws TypeError
    441      */
    442     function sodium_crypto_box_keypair_from_secretkey_and_publickey($sk, $pk)
    443     {
    444         return ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey($sk, $pk);
    445     }
    446 }
    447 if (!is_callable('sodium_crypto_box_open')) {
    448     /**
    449      * @see ParagonIE_Sodium_Compat::crypto_box_open()
    450      * @param string $message
    451      * @param string $nonce
    452      * @param string $kp
     510if (!is_callable('sodium_crypto_box_publickey')) {
     511    /**
     512     * @see ParagonIE_Sodium_Compat::crypto_box_publickey()
     513     * @param string $key_pair
     514     * @return string
     515     * @throws SodiumException
     516     * @throws TypeError
     517     */
     518    function sodium_crypto_box_publickey($key_pair)
     519    {
     520        return ParagonIE_Sodium_Compat::crypto_box_publickey($key_pair);
     521    }
     522}
     523if (!is_callable('sodium_crypto_box_publickey_from_secretkey')) {
     524    /**
     525     * @see ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey()
     526     * @param string $secret_key
     527     * @return string
     528     * @throws SodiumException
     529     * @throws TypeError
     530     */
     531    function sodium_crypto_box_publickey_from_secretkey($secret_key)
     532    {
     533        return ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey($secret_key);
     534    }
     535}
     536if (!is_callable('sodium_crypto_box_seal')) {
     537    /**
     538     * @see ParagonIE_Sodium_Compat::crypto_box_seal()
     539     * @param string $message
     540     * @param string $public_key
     541     * @return string
     542     * @throws SodiumException
     543     * @throws TypeError
     544     */
     545    function sodium_crypto_box_seal($message, $public_key)
     546    {
     547        return ParagonIE_Sodium_Compat::crypto_box_seal($message, $public_key);
     548    }
     549}
     550if (!is_callable('sodium_crypto_box_seal_open')) {
     551    /**
     552     * @see ParagonIE_Sodium_Compat::crypto_box_seal_open()
     553     * @param string $message
     554     * @param string $key_pair
    453555     * @return string|bool
    454      */
    455     function sodium_crypto_box_open($message, $nonce, $kp)
     556     * @throws SodiumException
     557     */
     558    function sodium_crypto_box_seal_open($message, $key_pair)
    456559    {
    457560        try {
    458             return ParagonIE_Sodium_Compat::crypto_box_open($message, $nonce, $kp);
    459         } catch (Error $ex) {
    460             return false;
    461         } catch (Exception $ex) {
    462             return false;
    463         }
    464     }
    465 }
    466 if (!is_callable('sodium_crypto_box_publickey')) {
    467     /**
    468      * @see ParagonIE_Sodium_Compat::crypto_box_publickey()
    469      * @param string $keypair
    470      * @return string
    471      * @throws SodiumException
    472      * @throws TypeError
    473      */
    474     function sodium_crypto_box_publickey($keypair)
    475     {
    476         return ParagonIE_Sodium_Compat::crypto_box_publickey($keypair);
    477     }
    478 }
    479 if (!is_callable('sodium_crypto_box_publickey_from_secretkey')) {
    480     /**
    481      * @see ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey()
    482      * @param string $sk
    483      * @return string
    484      * @throws SodiumException
    485      * @throws TypeError
    486      */
    487     function sodium_crypto_box_publickey_from_secretkey($sk)
    488     {
    489         return ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey($sk);
    490     }
    491 }
    492 if (!is_callable('sodium_crypto_box_seal')) {
    493     /**
    494      * @see ParagonIE_Sodium_Compat::crypto_box_seal()
    495      * @param string $message
    496      * @param string $publicKey
    497      * @return string
    498      * @throws SodiumException
    499      * @throws TypeError
    500      */
    501     function sodium_crypto_box_seal($message, $publicKey)
    502     {
    503         return ParagonIE_Sodium_Compat::crypto_box_seal($message, $publicKey);
    504     }
    505 }
    506 if (!is_callable('sodium_crypto_box_seal_open')) {
    507     /**
    508      * @see ParagonIE_Sodium_Compat::crypto_box_seal_open()
    509      * @param string $message
    510      * @param string $kp
    511      * @return string|bool
    512      * @throws SodiumException
    513      */
    514     function sodium_crypto_box_seal_open($message, $kp)
    515     {
    516         try {
    517             return ParagonIE_Sodium_Compat::crypto_box_seal_open($message, $kp);
     561            return ParagonIE_Sodium_Compat::crypto_box_seal_open($message, $key_pair);
    518562        } catch (SodiumException $ex) {
    519563            if ($ex->getMessage() === 'Argument 2 must be CRYPTO_BOX_KEYPAIRBYTES long.') {
     
    527571    /**
    528572     * @see ParagonIE_Sodium_Compat::crypto_box_secretkey()
    529      * @param string $keypair
    530      * @return string
    531      * @throws SodiumException
    532      * @throws TypeError
    533      */
    534     function sodium_crypto_box_secretkey($keypair)
    535     {
    536         return ParagonIE_Sodium_Compat::crypto_box_secretkey($keypair);
     573     * @param string $key_pair
     574     * @return string
     575     * @throws SodiumException
     576     * @throws TypeError
     577     */
     578    function sodium_crypto_box_secretkey($key_pair)
     579    {
     580        return ParagonIE_Sodium_Compat::crypto_box_secretkey($key_pair);
    537581    }
    538582}
     
    555599     * @param string $message
    556600     * @param string|null $key
    557      * @param int $outLen
    558      * @return string
    559      * @throws SodiumException
    560      * @throws TypeError
    561      */
    562     function sodium_crypto_generichash($message, $key = null, $outLen = 32)
    563     {
    564         return ParagonIE_Sodium_Compat::crypto_generichash($message, $key, $outLen);
     601     * @param int $length
     602     * @return string
     603     * @throws SodiumException
     604     * @throws TypeError
     605     */
     606    function sodium_crypto_generichash($message, $key = null, $length = 32)
     607    {
     608        return ParagonIE_Sodium_Compat::crypto_generichash($message, $key, $length);
    565609    }
    566610}
     
    568612    /**
    569613     * @see ParagonIE_Sodium_Compat::crypto_generichash_final()
    570      * @param string|null $ctx
     614     * @param string|null $state
    571615     * @param int $outputLength
    572616     * @return string
     
    574618     * @throws TypeError
    575619     */
    576     function sodium_crypto_generichash_final(&$ctx, $outputLength = 32)
    577     {
    578         return ParagonIE_Sodium_Compat::crypto_generichash_final($ctx, $outputLength);
     620    function sodium_crypto_generichash_final(&$state, $outputLength = 32)
     621    {
     622        return ParagonIE_Sodium_Compat::crypto_generichash_final($state, $outputLength);
    579623    }
    580624}
     
    583627     * @see ParagonIE_Sodium_Compat::crypto_generichash_init()
    584628     * @param string|null $key
    585      * @param int $outLen
    586      * @return string
    587      * @throws SodiumException
    588      * @throws TypeError
    589      */
    590     function sodium_crypto_generichash_init($key = null, $outLen = 32)
    591     {
    592         return ParagonIE_Sodium_Compat::crypto_generichash_init($key, $outLen);
     629     * @param int $length
     630     * @return string
     631     * @throws SodiumException
     632     * @throws TypeError
     633     */
     634    function sodium_crypto_generichash_init($key = null, $length = 32)
     635    {
     636        return ParagonIE_Sodium_Compat::crypto_generichash_init($key, $length);
    593637    }
    594638}
     
    607651    /**
    608652     * @see ParagonIE_Sodium_Compat::crypto_generichash_update()
    609      * @param string|null $ctx
     653     * @param string|null $state
    610654     * @param string $message
    611655     * @return void
     
    613657     * @throws TypeError
    614658     */
    615     function sodium_crypto_generichash_update(&$ctx, $message = '')
    616     {
    617         ParagonIE_Sodium_Compat::crypto_generichash_update($ctx, $message);
     659    function sodium_crypto_generichash_update(&$state, $message = '')
     660    {
     661        ParagonIE_Sodium_Compat::crypto_generichash_update($state, $message);
    618662    }
    619663}
     
    632676    /**
    633677     * @see ParagonIE_Sodium_Compat::crypto_kdf_derive_from_key()
    634      * @param int $subkey_len
     678     * @param int $subkey_length
    635679     * @param int $subkey_id
    636680     * @param string $context
     
    639683     * @throws Exception
    640684     */
    641     function sodium_crypto_kdf_derive_from_key($subkey_len, $subkey_id, $context, $key)
     685    function sodium_crypto_kdf_derive_from_key($subkey_length, $subkey_id, $context, $key)
    642686    {
    643687        return ParagonIE_Sodium_Compat::crypto_kdf_derive_from_key(
    644             $subkey_len,
     688            $subkey_length,
    645689            $subkey_id,
    646690            $context,
     
    693737if (!is_callable('sodium_crypto_kx_client_session_keys')) {
    694738    /**
    695      * @param string $keypair
    696      * @param string $serverPublicKey
     739     * @param string $client_key_pair
     740     * @param string $server_key
    697741     * @return array{0: string, 1: string}
    698742     * @throws SodiumException
    699743     */
    700     function sodium_crypto_kx_client_session_keys($keypair, $serverPublicKey)
    701     {
    702         return ParagonIE_Sodium_Compat::crypto_kx_client_session_keys($keypair, $serverPublicKey);
     744    function sodium_crypto_kx_client_session_keys($client_key_pair, $server_key)
     745    {
     746        return ParagonIE_Sodium_Compat::crypto_kx_client_session_keys($client_key_pair, $server_key);
    703747    }
    704748}
    705749if (!is_callable('sodium_crypto_kx_server_session_keys')) {
    706750    /**
    707      * @param string $keypair
    708      * @param string $clientPublicKey
     751     * @param string $server_key_pair
     752     * @param string $client_key
    709753     * @return array{0: string, 1: string}
    710754     * @throws SodiumException
    711755     */
    712     function sodium_crypto_kx_server_session_keys($keypair, $clientPublicKey)
    713     {
    714         return ParagonIE_Sodium_Compat::crypto_kx_server_session_keys($keypair, $clientPublicKey);
     756    function sodium_crypto_kx_server_session_keys($server_key_pair, $client_key)
     757    {
     758        return ParagonIE_Sodium_Compat::crypto_kx_server_session_keys($server_key_pair, $client_key);
    715759    }
    716760}
    717761if (!is_callable('sodium_crypto_kx_secretkey')) {
    718762    /**
    719      * @param string $keypair
    720      * @return string
    721      * @throws Exception
    722      */
    723     function sodium_crypto_kx_secretkey($keypair)
    724     {
    725         return ParagonIE_Sodium_Compat::crypto_kx_secretkey($keypair);
     763     * @param string $key_pair
     764     * @return string
     765     * @throws Exception
     766     */
     767    function sodium_crypto_kx_secretkey($key_pair)
     768    {
     769        return ParagonIE_Sodium_Compat::crypto_kx_secretkey($key_pair);
    726770    }
    727771}
    728772if (!is_callable('sodium_crypto_kx_publickey')) {
    729773    /**
    730      * @param string $keypair
    731      * @return string
    732      * @throws Exception
    733      */
    734     function sodium_crypto_kx_publickey($keypair)
    735     {
    736         return ParagonIE_Sodium_Compat::crypto_kx_publickey($keypair);
     774     * @param string $key_pair
     775     * @return string
     776     * @throws Exception
     777     */
     778    function sodium_crypto_kx_publickey($key_pair)
     779    {
     780        return ParagonIE_Sodium_Compat::crypto_kx_publickey($key_pair);
    737781    }
    738782}
     
    740784    /**
    741785     * @see ParagonIE_Sodium_Compat::crypto_pwhash()
    742      * @param int $outlen
     786     * @param int $length
    743787     * @param string $passwd
    744788     * @param string $salt
     
    750794     * @throws TypeError
    751795     */
    752     function sodium_crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit, $algo = null)
    753     {
    754         return ParagonIE_Sodium_Compat::crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit, $algo);
     796    function sodium_crypto_pwhash($length, $passwd, $salt, $opslimit, $memlimit, $algo = null)
     797    {
     798        return ParagonIE_Sodium_Compat::crypto_pwhash($length, $passwd, $salt, $opslimit, $memlimit, $algo);
    755799    }
    756800}
     
    802846    /**
    803847     * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256()
    804      * @param int $outlen
     848     * @param int $length
    805849     * @param string $passwd
    806850     * @param string $salt
     
    811855     * @throws TypeError
    812856     */
    813     function sodium_crypto_pwhash_scryptsalsa208sha256($outlen, $passwd, $salt, $opslimit, $memlimit)
    814     {
    815         return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256($outlen, $passwd, $salt, $opslimit, $memlimit);
     857    function sodium_crypto_pwhash_scryptsalsa208sha256($length, $passwd, $salt, $opslimit, $memlimit)
     858    {
     859        return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256(
     860            $length,
     861            $passwd,
     862            $salt,
     863            $opslimit,
     864            $memlimit
     865        );
    816866    }
    817867}
     
    901951    /**
    902952     * @see ParagonIE_Sodium_Compat::crypto_secretbox_open()
    903      * @param string $message
     953     * @param string $ciphertext
    904954     * @param string $nonce
    905955     * @param string $key
    906956     * @return string|bool
    907957     */
    908     function sodium_crypto_secretbox_open($message, $nonce, $key)
     958    function sodium_crypto_secretbox_open($ciphertext, $nonce, $key)
    909959    {
    910960        try {
    911             return ParagonIE_Sodium_Compat::crypto_secretbox_open($message, $nonce, $key);
     961            return ParagonIE_Sodium_Compat::crypto_secretbox_open($ciphertext, $nonce, $key);
    912962        } catch (Error $ex) {
    913963            return false;
     
    931981    /**
    932982     * @param string $state
    933      * @param string $msg
    934      * @param string $aad
     983     * @param string $message
     984     * @param string $additional_data
    935985     * @param int $tag
    936986     * @return string
    937987     * @throws SodiumException
    938988     */
    939     function sodium_crypto_secretstream_xchacha20poly1305_push(&$state, $msg, $aad = '', $tag = 0)
    940     {
    941         return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_push($state, $msg, $aad, $tag);
     989    function sodium_crypto_secretstream_xchacha20poly1305_push(
     990        &$state,
     991        $message,
     992        $additional_data = '',
     993        $tag = 0
     994    ) {
     995        return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_push(
     996            $state,
     997            $message,
     998            $additional_data,
     999            $tag
     1000        );
    9421001    }
    9431002}
     
    9571016    /**
    9581017     * @param string $state
    959      * @param string $cipher
    960      * @param string $aad
     1018     * @param string $ciphertext
     1019     * @param string $additional_data
    9611020     * @return bool|array{0: string, 1: int}
    9621021     * @throws SodiumException
    9631022     */
    964     function sodium_crypto_secretstream_xchacha20poly1305_pull(&$state, $cipher, $aad = '')
    965     {
    966         return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_pull($state, $cipher, $aad);
     1023    function sodium_crypto_secretstream_xchacha20poly1305_pull(&$state, $ciphertext, $additional_data = '')
     1024    {
     1025        return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_pull(
     1026            $state,
     1027            $ciphertext,
     1028            $additional_data
     1029        );
    9671030    }
    9681031}
     
    10171080     * @see ParagonIE_Sodium_Compat::crypto_sign()
    10181081     * @param string $message
    1019      * @param string $sk
    1020      * @return string
    1021      * @throws SodiumException
    1022      * @throws TypeError
    1023      */
    1024     function sodium_crypto_sign($message, $sk)
    1025     {
    1026         return ParagonIE_Sodium_Compat::crypto_sign($message, $sk);
     1082     * @param string $secret_key
     1083     * @return string
     1084     * @throws SodiumException
     1085     * @throws TypeError
     1086     */
     1087    function sodium_crypto_sign($message, $secret_key)
     1088    {
     1089        return ParagonIE_Sodium_Compat::crypto_sign($message, $secret_key);
    10271090    }
    10281091}
     
    10311094     * @see ParagonIE_Sodium_Compat::crypto_sign_detached()
    10321095     * @param string $message
    1033      * @param string $sk
    1034      * @return string
    1035      * @throws SodiumException
    1036      * @throws TypeError
    1037      */
    1038     function sodium_crypto_sign_detached($message, $sk)
    1039     {
    1040         return ParagonIE_Sodium_Compat::crypto_sign_detached($message, $sk);
     1096     * @param string $secret_key
     1097     * @return string
     1098     * @throws SodiumException
     1099     * @throws TypeError
     1100     */
     1101    function sodium_crypto_sign_detached($message, $secret_key)
     1102    {
     1103        return ParagonIE_Sodium_Compat::crypto_sign_detached($message, $secret_key);
    10411104    }
    10421105}
     
    10441107    /**
    10451108     * @see ParagonIE_Sodium_Compat::crypto_sign_keypair_from_secretkey_and_publickey()
    1046      * @param string $sk
    1047      * @param string $pk
    1048      * @return string
    1049      * @throws SodiumException
    1050      * @throws TypeError
    1051      */
    1052     function sodium_crypto_sign_keypair_from_secretkey_and_publickey($sk, $pk)
    1053     {
    1054         return ParagonIE_Sodium_Compat::crypto_sign_keypair_from_secretkey_and_publickey($sk, $pk);
     1109     * @param string $secret_key
     1110     * @param string $public_key
     1111     * @return string
     1112     * @throws SodiumException
     1113     * @throws TypeError
     1114     */
     1115    function sodium_crypto_sign_keypair_from_secretkey_and_publickey($secret_key, $public_key)
     1116    {
     1117        return ParagonIE_Sodium_Compat::crypto_sign_keypair_from_secretkey_and_publickey($secret_key, $public_key);
    10551118    }
    10561119}
     
    10711134     * @see ParagonIE_Sodium_Compat::crypto_sign_open()
    10721135     * @param string $signedMessage
    1073      * @param string $pk
     1136     * @param string $public_key
    10741137     * @return string|bool
    10751138     */
    1076     function sodium_crypto_sign_open($signedMessage, $pk)
     1139    function sodium_crypto_sign_open($signedMessage, $public_key)
    10771140    {
    10781141        try {
    1079             return ParagonIE_Sodium_Compat::crypto_sign_open($signedMessage, $pk);
     1142            return ParagonIE_Sodium_Compat::crypto_sign_open($signedMessage, $public_key);
    10801143        } catch (Error $ex) {
    10811144            return false;
     
    10881151    /**
    10891152     * @see ParagonIE_Sodium_Compat::crypto_sign_publickey()
    1090      * @param string $keypair
    1091      * @return string
    1092      * @throws SodiumException
    1093      * @throws TypeError
    1094      */
    1095     function sodium_crypto_sign_publickey($keypair)
    1096     {
    1097         return ParagonIE_Sodium_Compat::crypto_sign_publickey($keypair);
     1153     * @param string $key_pair
     1154     * @return string
     1155     * @throws SodiumException
     1156     * @throws TypeError
     1157     */
     1158    function sodium_crypto_sign_publickey($key_pair)
     1159    {
     1160        return ParagonIE_Sodium_Compat::crypto_sign_publickey($key_pair);
    10981161    }
    10991162}
     
    11011164    /**
    11021165     * @see ParagonIE_Sodium_Compat::crypto_sign_publickey_from_secretkey()
    1103      * @param string $sk
    1104      * @return string
    1105      * @throws SodiumException
    1106      * @throws TypeError
    1107      */
    1108     function sodium_crypto_sign_publickey_from_secretkey($sk)
    1109     {
    1110         return ParagonIE_Sodium_Compat::crypto_sign_publickey_from_secretkey($sk);
     1166     * @param string $secret_key
     1167     * @return string
     1168     * @throws SodiumException
     1169     * @throws TypeError
     1170     */
     1171    function sodium_crypto_sign_publickey_from_secretkey($secret_key)
     1172    {
     1173        return ParagonIE_Sodium_Compat::crypto_sign_publickey_from_secretkey($secret_key);
    11111174    }
    11121175}
     
    11141177    /**
    11151178     * @see ParagonIE_Sodium_Compat::crypto_sign_secretkey()
    1116      * @param string $keypair
    1117      * @return string
    1118      * @throws SodiumException
    1119      * @throws TypeError
    1120      */
    1121     function sodium_crypto_sign_secretkey($keypair)
    1122     {
    1123         return ParagonIE_Sodium_Compat::crypto_sign_secretkey($keypair);
     1179     * @param string $key_pair
     1180     * @return string
     1181     * @throws SodiumException
     1182     * @throws TypeError
     1183     */
     1184    function sodium_crypto_sign_secretkey($key_pair)
     1185    {
     1186        return ParagonIE_Sodium_Compat::crypto_sign_secretkey($key_pair);
    11241187    }
    11251188}
     
    11421205     * @param string $signature
    11431206     * @param string $message
    1144      * @param string $pk
     1207     * @param string $public_key
    11451208     * @return bool
    11461209     * @throws SodiumException
    11471210     * @throws TypeError
    11481211     */
    1149     function sodium_crypto_sign_verify_detached($signature, $message, $pk)
    1150     {
    1151         return ParagonIE_Sodium_Compat::crypto_sign_verify_detached($signature, $message, $pk);
     1212    function sodium_crypto_sign_verify_detached($signature, $message, $public_key)
     1213    {
     1214        return ParagonIE_Sodium_Compat::crypto_sign_verify_detached($signature, $message, $public_key);
    11521215    }
    11531216}
     
    11551218    /**
    11561219     * @see ParagonIE_Sodium_Compat::crypto_sign_ed25519_pk_to_curve25519()
    1157      * @param string $pk
    1158      * @return string
    1159      * @throws SodiumException
    1160      * @throws TypeError
    1161      */
    1162     function sodium_crypto_sign_ed25519_pk_to_curve25519($pk)
    1163     {
    1164         return ParagonIE_Sodium_Compat::crypto_sign_ed25519_pk_to_curve25519($pk);
     1220     * @param string $public_key
     1221     * @return string
     1222     * @throws SodiumException
     1223     * @throws TypeError
     1224     */
     1225    function sodium_crypto_sign_ed25519_pk_to_curve25519($public_key)
     1226    {
     1227        return ParagonIE_Sodium_Compat::crypto_sign_ed25519_pk_to_curve25519($public_key);
    11651228    }
    11661229}
     
    11681231    /**
    11691232     * @see ParagonIE_Sodium_Compat::crypto_sign_ed25519_sk_to_curve25519()
    1170      * @param string $sk
    1171      * @return string
    1172      * @throws SodiumException
    1173      * @throws TypeError
    1174      */
    1175     function sodium_crypto_sign_ed25519_sk_to_curve25519($sk)
    1176     {
    1177         return ParagonIE_Sodium_Compat::crypto_sign_ed25519_sk_to_curve25519($sk);
     1233     * @param string $secret_key
     1234     * @return string
     1235     * @throws SodiumException
     1236     * @throws TypeError
     1237     */
     1238    function sodium_crypto_sign_ed25519_sk_to_curve25519($secret_key)
     1239    {
     1240        return ParagonIE_Sodium_Compat::crypto_sign_ed25519_sk_to_curve25519($secret_key);
    11781241    }
    11791242}
     
    11811244    /**
    11821245     * @see ParagonIE_Sodium_Compat::crypto_stream()
    1183      * @param int $len
     1246     * @param int $length
    11841247     * @param string $nonce
    11851248     * @param string $key
     
    11881251     * @throws TypeError
    11891252     */
    1190     function sodium_crypto_stream($len, $nonce, $key)
    1191     {
    1192         return ParagonIE_Sodium_Compat::crypto_stream($len, $nonce, $key);
     1253    function sodium_crypto_stream($length, $nonce, $key)
     1254    {
     1255        return ParagonIE_Sodium_Compat::crypto_stream($length, $nonce, $key);
    11931256    }
    11941257}
     
    12241287     * @see ParagonIE_Sodium_Compat::hex2bin()
    12251288     * @param string $string
    1226      * @return string
    1227      * @throws SodiumException
    1228      * @throws TypeError
    1229      */
    1230     function sodium_hex2bin($string)
    1231     {
    1232         return ParagonIE_Sodium_Compat::hex2bin($string);
     1289     * @param string $ignore
     1290     * @return string
     1291     * @throws SodiumException
     1292     * @throws TypeError
     1293     */
     1294    function sodium_hex2bin($string, $ignore = '')
     1295    {
     1296        return ParagonIE_Sodium_Compat::hex2bin($string, $ignore);
    12331297    }
    12341298}
     
    12791343    /**
    12801344     * @see ParagonIE_Sodium_Compat::memcmp()
    1281      * @param string $a
    1282      * @param string $b
     1345     * @param string $string1
     1346     * @param string $string2
    12831347     * @return int
    12841348     * @throws SodiumException
    12851349     * @throws TypeError
    12861350     */
    1287     function sodium_memcmp($a, $b)
    1288     {
    1289         return ParagonIE_Sodium_Compat::memcmp($a, $b);
     1351    function sodium_memcmp($string1, $string2)
     1352    {
     1353        return ParagonIE_Sodium_Compat::memcmp($string1, $string2);
    12901354    }
    12911355}
     
    12931357    /**
    12941358     * @see ParagonIE_Sodium_Compat::memzero()
    1295      * @param string $str
     1359     * @param string $string
    12961360     * @return void
    12971361     * @throws SodiumException
    12981362     * @throws TypeError
    12991363     */
    1300     function sodium_memzero(&$str)
    1301     {
    1302         ParagonIE_Sodium_Compat::memzero($str);
     1364    function sodium_memzero(&$string)
     1365    {
     1366        ParagonIE_Sodium_Compat::memzero($string);
    13031367    }
    13041368}
     
    13071371     * @see ParagonIE_Sodium_Compat::pad()
    13081372     * @param string $unpadded
    1309      * @param int $blockSize
    1310      * @return int
    1311      * @throws SodiumException
    1312      * @throws TypeError
    1313      */
    1314     function sodium_pad($unpadded, $blockSize)
    1315     {
    1316         return ParagonIE_Sodium_Compat::pad($unpadded, $blockSize, true);
     1373     * @param int $block_size
     1374     * @return string
     1375     * @throws SodiumException
     1376     * @throws TypeError
     1377     */
     1378    function sodium_pad($unpadded, $block_size)
     1379    {
     1380        return ParagonIE_Sodium_Compat::pad($unpadded, $block_size, true);
    13171381    }
    13181382}
     
    13211385     * @see ParagonIE_Sodium_Compat::pad()
    13221386     * @param string $padded
    1323      * @param int $blockSize
    1324      * @return int
    1325      * @throws SodiumException
    1326      * @throws TypeError
    1327      */
    1328     function sodium_unpad($padded, $blockSize)
    1329     {
    1330         return ParagonIE_Sodium_Compat::unpad($padded, $blockSize, true);
     1387     * @param int $block_size
     1388     * @return string
     1389     * @throws SodiumException
     1390     * @throws TypeError
     1391     */
     1392    function sodium_unpad($padded, $block_size)
     1393    {
     1394        return ParagonIE_Sodium_Compat::unpad($padded, $block_size, true);
    13311395    }
    13321396}
  • trunk/src/wp-includes/sodium_compat/lib/ristretto255.php

    r51002 r54310  
    5757     * @see ParagonIE_Sodium_Compat::ristretto255_from_hash()
    5858     *
    59      * @param string $r
    60      * @return string
    61      * @throws SodiumException
    62      */
    63     function sodium_crypto_core_ristretto255_from_hash($r)
    64     {
    65         return ParagonIE_Sodium_Compat::ristretto255_from_hash($r, true);
     59     * @param string $s
     60     * @return string
     61     * @throws SodiumException
     62     */
     63    function sodium_crypto_core_ristretto255_from_hash($s)
     64    {
     65        return ParagonIE_Sodium_Compat::ristretto255_from_hash($s, true);
    6666    }
    6767}
     
    7070     * @see ParagonIE_Sodium_Compat::ristretto255_is_valid_point()
    7171     *
    72      * @param string $p
     72     * @param string $s
    7373     * @return bool
    7474     * @throws SodiumException
    7575     */
    76     function sodium_crypto_core_ristretto255_is_valid_point($p)
    77     {
    78         return ParagonIE_Sodium_Compat::ristretto255_is_valid_point($p, true);
     76    function sodium_crypto_core_ristretto255_is_valid_point($s)
     77    {
     78        return ParagonIE_Sodium_Compat::ristretto255_is_valid_point($s, true);
    7979    }
    8080}
     
    9595     * @see ParagonIE_Sodium_Compat::ristretto255_scalar_add()
    9696     *
    97      * @param string $p
    98      * @param string $q
    99      * @return string
    100      * @throws SodiumException
    101      */
    102     function sodium_crypto_core_ristretto255_scalar_add($p, $q)
    103     {
    104         return ParagonIE_Sodium_Compat::ristretto255_scalar_add($p, $q, true);
     97     * @param string $x
     98     * @param string $y
     99     * @return string
     100     * @throws SodiumException
     101     */
     102    function sodium_crypto_core_ristretto255_scalar_add($x, $y)
     103    {
     104        return ParagonIE_Sodium_Compat::ristretto255_scalar_add($x, $y, true);
    105105    }
    106106}
     
    109109     * @see ParagonIE_Sodium_Compat::ristretto255_scalar_complement()
    110110     *
    111      * @param string $p
    112      * @return string
    113      * @throws SodiumException
    114      */
    115     function sodium_crypto_core_ristretto255_scalar_complement($p)
    116     {
    117         return ParagonIE_Sodium_Compat::ristretto255_scalar_complement($p, true);
     111     * @param string $s
     112     * @return string
     113     * @throws SodiumException
     114     */
     115    function sodium_crypto_core_ristretto255_scalar_complement($s)
     116    {
     117        return ParagonIE_Sodium_Compat::ristretto255_scalar_complement($s, true);
    118118    }
    119119}
     
    135135     * @see ParagonIE_Sodium_Compat::ristretto255_scalar_mul()
    136136     *
    137      * @param string $p
    138      * @param string $q
    139      * @return string
    140      * @throws SodiumException
    141      */
    142     function sodium_crypto_core_ristretto255_scalar_mul($p, $q)
    143     {
    144         return ParagonIE_Sodium_Compat::ristretto255_scalar_mul($p, $q, true);
     137     * @param string $x
     138     * @param string $y
     139     * @return string
     140     * @throws SodiumException
     141     */
     142    function sodium_crypto_core_ristretto255_scalar_mul($x, $y)
     143    {
     144        return ParagonIE_Sodium_Compat::ristretto255_scalar_mul($x, $y, true);
    145145    }
    146146}
     
    149149     * @see ParagonIE_Sodium_Compat::ristretto255_scalar_negate()
    150150     *
    151      * @param string $p
    152      * @return string
    153      * @throws SodiumException
    154      */
    155     function sodium_crypto_core_ristretto255_scalar_negate($p)
    156     {
    157         return ParagonIE_Sodium_Compat::ristretto255_scalar_negate($p, true);
     151     * @param string $s
     152     * @return string
     153     * @throws SodiumException
     154     */
     155    function sodium_crypto_core_ristretto255_scalar_negate($s)
     156    {
     157        return ParagonIE_Sodium_Compat::ristretto255_scalar_negate($s, true);
    158158    }
    159159}
     
    174174     * @see ParagonIE_Sodium_Compat::ristretto255_scalar_reduce()
    175175     *
    176      * @param string $p
    177      * @return string
    178      * @throws SodiumException
    179      */
    180     function sodium_crypto_core_ristretto255_scalar_reduce($p)
    181     {
    182         return ParagonIE_Sodium_Compat::ristretto255_scalar_reduce($p, true);
     176     * @param string $s
     177     * @return string
     178     * @throws SodiumException
     179     */
     180    function sodium_crypto_core_ristretto255_scalar_reduce($s)
     181    {
     182        return ParagonIE_Sodium_Compat::ristretto255_scalar_reduce($s, true);
    183183    }
    184184}
     
    187187     * @see ParagonIE_Sodium_Compat::ristretto255_scalar_sub()
    188188     *
    189      * @param string $p
    190      * @param string $q
    191      * @return string
    192      * @throws SodiumException
    193      */
    194     function sodium_crypto_core_ristretto255_scalar_sub($p, $q)
    195     {
    196         return ParagonIE_Sodium_Compat::ristretto255_scalar_sub($p, $q, true);
     189     * @param string $x
     190     * @param string $y
     191     * @return string
     192     * @throws SodiumException
     193     */
     194    function sodium_crypto_core_ristretto255_scalar_sub($x, $y)
     195    {
     196        return ParagonIE_Sodium_Compat::ristretto255_scalar_sub($x, $y, true);
    197197    }
    198198}
  • trunk/src/wp-includes/sodium_compat/lib/sodium_compat.php

    r51002 r54310  
    779779     * @throws \SodiumException
    780780     * @throws \TypeError
     781     *
     782     * @psalm-suppress MissingParamType
     783     * @psalm-suppress MissingReturnType
     784     * @psalm-suppress ReferenceConstraintViolation
    781785     */
    782786    function memzero(&$str)
  • trunk/src/wp-includes/sodium_compat/src/Compat.php

    r54150 r54310  
    32203220     *
    32213221     * @param string $string Hexadecimal string
     3222     * @param string $ignore List of characters to ignore; useful for whitespace
    32223223     * @return string        Raw binary string
    32233224     * @throws SodiumException
     
    32263227     * @psalm-suppress MixedArgument
    32273228     */
    3228     public static function hex2bin($string)
     3229    public static function hex2bin($string, $ignore = '')
    32293230    {
    32303231        /* Type checks: */
    32313232        ParagonIE_Sodium_Core_Util::declareScalarType($string, 'string', 1);
     3233        ParagonIE_Sodium_Core_Util::declareScalarType($ignore, 'string', 2);
    32323234
    32333235        if (self::useNewSodiumAPI()) {
    32343236            if (is_callable('sodium_hex2bin')) {
    3235                 return (string) sodium_hex2bin($string);
     3237                return (string) sodium_hex2bin($string, $ignore);
    32363238            }
    32373239        }
    32383240        if (self::use_fallback('hex2bin')) {
    3239             return (string) call_user_func('\\Sodium\\hex2bin', $string);
    3240         }
    3241         return ParagonIE_Sodium_Core_Util::hex2bin($string);
     3241            return (string) call_user_func('\\Sodium\\hex2bin', $string, $ignore);
     3242        }
     3243        return ParagonIE_Sodium_Core_Util::hex2bin($string, $ignore);
    32423244    }
    32433245
  • trunk/src/wp-includes/sodium_compat/src/Core/Util.php

    r52988 r54310  
    310310     *
    311311     * @param string $hexString
     312     * @param string $ignore
    312313     * @param bool $strictPadding
    313314     * @return string (raw binary)
     
    315316     * @throws TypeError
    316317     */
    317     public static function hex2bin($hexString, $strictPadding = false)
     318    public static function hex2bin($hexString, $ignore = '', $strictPadding = false)
    318319    {
    319320        /* Type checks: */
     
    321322            throw new TypeError('Argument 1 must be a string, ' . gettype($hexString) . ' given.');
    322323        }
    323 
    324         /** @var int $hex_pos */
     324        if (!is_string($ignore)) {
     325            throw new TypeError('Argument 2 must be a string, ' . gettype($hexString) . ' given.');
     326        }
     327
    325328        $hex_pos = 0;
    326         /** @var string $bin */
    327329        $bin = '';
    328         /** @var int $c_acc */
    329330        $c_acc = 0;
    330         /** @var int $hex_len */
    331331        $hex_len = self::strlen($hexString);
    332         /** @var int $state */
    333332        $state = 0;
    334333        if (($hex_len & 1) !== 0) {
     
    348347            /** @var int $c */
    349348            $c = $chunk[$hex_pos];
    350             /** @var int $c_num */
    351349            $c_num = $c ^ 48;
    352             /** @var int $c_num0 */
    353350            $c_num0 = ($c_num - 10) >> 8;
    354             /** @var int $c_alpha */
    355351            $c_alpha = ($c & ~32) - 55;
    356             /** @var int $c_alpha0 */
    357352            $c_alpha0 = (($c_alpha - 10) ^ ($c_alpha - 16)) >> 8;
    358353            if (($c_num0 | $c_alpha0) === 0) {
     354                if ($ignore && $state === 0 && strpos($ignore, self::intToChr($c)) !== false) {
     355                    continue;
     356                }
    359357                throw new RangeException(
    360358                    'hex2bin() only expects hexadecimal characters'
    361359                );
    362360            }
    363             /** @var int $c_val */
    364361            $c_val = ($c_num0 & $c_num) | ($c_alpha & $c_alpha0);
    365362            if ($state === 0) {
     
    383380    public static function intArrayToString(array $ints)
    384381    {
    385         /** @var array<int, int> $args */
    386382        $args = $ints;
    387383        foreach ($args as $i => $v) {
Note: See TracChangeset for help on using the changeset viewer.