WordPress.org
Get WordPress

Make WordPress Core

Changeset 58752


Ignore:
Timestamp:
07/18/2024 12:58:40 PM (3 months ago)
Author:
SergeyBiryukov
Message:

Upgrade/Install: Update sodium_compat to v1.21.1.

The latest version of sodium_compat includes support for AEGIS and preliminary support for PHP 8.4.

Additionally, the PHP 8.2+ SensitiveParameter attribute is now applied where appropriate to functions in the public API. This attribute is used to mark parameters that are sensitive and should be redacted from stack traces.

References:

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

Props jrf, dd32, paragoninitiativeenterprises.
Fixes #61686.

Location:
trunk/src/wp-includes/sodium_compat
Files:
1 deleted
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/wp-includes/sodium_compat/autoload.php

    r54150 r58752  
    5555    require_once dirname(__FILE__) . '/lib/namespaced.php';
    5656    require_once dirname(__FILE__) . '/lib/sodium_compat.php';
     57    if (!defined('SODIUM_CRYPTO_AEAD_AEGIS128L_KEYBYTES')) {
     58        require_once dirname(__FILE__) . '/lib/php84compat_const.php';
     59    }
    5760} else {
    5861    require_once dirname(__FILE__) . '/src/PHP52/SplFixedArray.php';
    … …  
    7275    require_once(dirname(__FILE__) . '/lib/php72compat.php');
    7376}
     77if (PHP_VERSION_ID < 80400 || !extension_loaded('sodium')) {
     78    require_once dirname(__FILE__) . '/lib/php84compat.php';
     79}
    7480require_once(dirname(__FILE__) . '/lib/stream-xchacha20.php');
    7581require_once(dirname(__FILE__) . '/lib/ristretto255.php');

  • trunk/src/wp-includes/sodium_compat/lib/php72compat.php

    r55699 r58752  
    1515    'BASE64_VARIANT_URLSAFE',
    1616    'BASE64_VARIANT_URLSAFE_NO_PADDING',
     17    'CRYPTO_AEAD_AES256GCM_KEYBYTES',
     18    'CRYPTO_AEAD_AES256GCM_NSECBYTES',
     19    'CRYPTO_AEAD_AES256GCM_NPUBBYTES',
     20    'CRYPTO_AEAD_AES256GCM_ABYTES',
    1721    'CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES',
    1822    'CRYPTO_AEAD_CHACHA20POLY1305_NSECBYTES',
    1923    'CRYPTO_AEAD_CHACHA20POLY1305_NPUBBYTES',
    2024    'CRYPTO_AEAD_CHACHA20POLY1305_ABYTES',
    21     'CRYPTO_AEAD_AES256GCM_KEYBYTES',
    22     'CRYPTO_AEAD_AES256GCM_NSECBYTES',
    23     'CRYPTO_AEAD_AES256GCM_NPUBBYTES',
    24     'CRYPTO_AEAD_AES256GCM_ABYTES',
    2525    'CRYPTO_AEAD_CHACHA20POLY1305_IETF_KEYBYTES',
    2626    'CRYPTO_AEAD_CHACHA20POLY1305_IETF_NSECBYTES',
    … …  
    116116     * @throws SodiumException
    117117     */
    118     function sodium_add(&$string1, $string2)
    119     {
     118    function sodium_add(
     119        #[\SensitiveParameter]
     120        &$string1,
     121        #[\SensitiveParameter]
     122        $string2
     123    ) {
    120124        ParagonIE_Sodium_Compat::add($string1, $string2);
    121125    }
    … …  
    131135     * @throws TypeError
    132136     */
    133     function sodium_base642bin($string, $variant, $ignore ='')
    134     {
     137    function sodium_base642bin(
     138        #[\SensitiveParameter]
     139        $string,
     140        $variant,
     141        $ignore =''
     142    ) {
    135143        return ParagonIE_Sodium_Compat::base642bin($string, $variant, $ignore);
    136144    }
    … …  
    145153     * @throws TypeError
    146154     */
    147     function sodium_bin2base64($string, $variant)
    148     {
     155    function sodium_bin2base64(
     156        #[\SensitiveParameter]
     157        $string,
     158        $variant
     159    ) {
    149160        return ParagonIE_Sodium_Compat::bin2base64($string, $variant);
    150161    }
    … …  
    158169     * @throws TypeError
    159170     */
    160     function sodium_bin2hex($string)
    161     {
     171    function sodium_bin2hex(
     172        #[\SensitiveParameter]
     173        $string
     174    ) {
    162175        return ParagonIE_Sodium_Compat::bin2hex($string);
    163176    }
    … …  
    172185     * @throws TypeError
    173186     */
    174     function sodium_compare($string1, $string2)
    175     {
     187    function sodium_compare(
     188        #[\SensitiveParameter]
     189        $string1,
     190        #[\SensitiveParameter]
     191        $string2
     192    ) {
    176193        return ParagonIE_Sodium_Compat::compare($string1, $string2);
    177194    }
    … …  
    186203     * @return string|bool
    187204     */
    188     function sodium_crypto_aead_aes256gcm_decrypt($ciphertext, $additional_data, $nonce, $key)
    189     {
     205    function sodium_crypto_aead_aes256gcm_decrypt(
     206        $ciphertext,
     207        $additional_data,
     208        $nonce,
     209        #[\SensitiveParameter]
     210        $key
     211    ) {
    190212        try {
    191213            return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt(
    … …  
    216238     * @throws TypeError
    217239     */
    218     function sodium_crypto_aead_aes256gcm_encrypt($message, $additional_data, $nonce, $key)
    219     {
     240    function sodium_crypto_aead_aes256gcm_encrypt(
     241        #[\SensitiveParameter]
     242        $message,
     243        $additional_data,
     244        $nonce,
     245        #[\SensitiveParameter]
     246        $key
     247    ) {
    220248        return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt($message, $additional_data, $nonce, $key);
    221249    }
    … …  
    240268     * @return string|bool
    241269     */
    242     function sodium_crypto_aead_chacha20poly1305_decrypt($ciphertext, $additional_data, $nonce, $key)
    243     {
     270    function sodium_crypto_aead_chacha20poly1305_decrypt(
     271        $ciphertext,
     272        $additional_data,
     273        $nonce,
     274        #[\SensitiveParameter]
     275        $key
     276    ) {
    244277        try {
    245278            return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt(
    … …  
    267300     * @throws TypeError
    268301     */
    269     function sodium_crypto_aead_chacha20poly1305_encrypt($message, $additional_data, $nonce, $key)
    270     {
     302    function sodium_crypto_aead_chacha20poly1305_encrypt(
     303        #[\SensitiveParameter]
     304        $message,
     305        $additional_data,
     306        $nonce,
     307        #[\SensitiveParameter]
     308        $key
     309    ) {
    271310        return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt(
    272311            $message,
    … …  
    297336     * @return string|bool
    298337     */
    299     function sodium_crypto_aead_chacha20poly1305_ietf_decrypt($message, $additional_data, $nonce, $key)
    300     {
     338    function sodium_crypto_aead_chacha20poly1305_ietf_decrypt(
     339        $message,
     340        $additional_data,
     341        $nonce,
     342        #[\SensitiveParameter]
     343        $key
     344    ) {
    301345        try {
    302346            return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt(
    … …  
    324368     * @throws TypeError
    325369     */
    326     function sodium_crypto_aead_chacha20poly1305_ietf_encrypt($message, $additional_data, $nonce, $key)
    327     {
     370    function sodium_crypto_aead_chacha20poly1305_ietf_encrypt(
     371        #[\SensitiveParameter]
     372        $message,
     373        $additional_data,
     374        $nonce,
     375        #[\SensitiveParameter]
     376        $key
     377    ) {
    328378        return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt(
    329379            $message,
    … …  
    354404     * @return string|bool
    355405     */
    356     function sodium_crypto_aead_xchacha20poly1305_ietf_decrypt($ciphertext, $additional_data, $nonce, $key)
    357     {
     406    function sodium_crypto_aead_xchacha20poly1305_ietf_decrypt(
     407        $ciphertext,
     408        $additional_data,
     409        $nonce,
     410        #[\SensitiveParameter]
     411        $key
     412    ) {
    358413        try {
    359414            return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_decrypt(
    … …  
    383438     */
    384439    function sodium_crypto_aead_xchacha20poly1305_ietf_encrypt(
     440        #[\SensitiveParameter]
    385441        $message,
    386442        $additional_data,
    387443        $nonce,
     444        #[\SensitiveParameter]
    388445        $key
    389446    ) {
    … …  
    417474     * @throws TypeError
    418475     */
    419     function sodium_crypto_auth($message, $key)
    420     {
     476    function sodium_crypto_auth(
     477        $message,
     478        #[\SensitiveParameter]
     479        $key
     480    ) {
    421481        return ParagonIE_Sodium_Compat::crypto_auth($message, $key);
    422482    }
    … …  
    443503     * @throws TypeError
    444504     */
    445     function sodium_crypto_auth_verify($mac, $message, $key)
    446     {
     505    function sodium_crypto_auth_verify(
     506        $mac,
     507        $message,
     508        #[\SensitiveParameter]
     509        $key
     510    ) {
    447511        return ParagonIE_Sodium_Compat::crypto_auth_verify($mac, $message, $key);
    448512    }
    … …  
    458522     * @throws TypeError
    459523     */
    460     function sodium_crypto_box($message, $nonce, $key_pair)
    461     {
     524    function sodium_crypto_box(
     525        #[\SensitiveParameter]
     526        $message,
     527        $nonce,
     528        #[\SensitiveParameter]
     529        $key_pair
     530    ) {
    462531        return ParagonIE_Sodium_Compat::crypto_box($message, $nonce, $key_pair);
    463532    }
    … …  
    484553     * @throws TypeError
    485554     */
    486     function sodium_crypto_box_keypair_from_secretkey_and_publickey($secret_key, $public_key)
    487     {
     555    function sodium_crypto_box_keypair_from_secretkey_and_publickey(
     556        #[\SensitiveParameter]
     557        $secret_key,
     558        $public_key
     559    ) {
    488560        return ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey($secret_key, $public_key);
    489561    }
    … …  
    497569     * @return string|bool
    498570     */
    499     function sodium_crypto_box_open($ciphertext, $nonce, $key_pair)
    500     {
     571    function sodium_crypto_box_open(
     572        $ciphertext,
     573        $nonce,
     574        #[\SensitiveParameter]
     575        $key_pair
     576    ) {
    501577        try {
    502578            return ParagonIE_Sodium_Compat::crypto_box_open($ciphertext, $nonce, $key_pair);
    … …  
    516592     * @throws TypeError
    517593     */
    518     function sodium_crypto_box_publickey($key_pair)
    519     {
     594    function sodium_crypto_box_publickey(
     595        #[\SensitiveParameter]
     596        $key_pair
     597    ) {
    520598        return ParagonIE_Sodium_Compat::crypto_box_publickey($key_pair);
    521599    }
    … …  
    529607     * @throws TypeError
    530608     */
    531     function sodium_crypto_box_publickey_from_secretkey($secret_key)
    532     {
     609    function sodium_crypto_box_publickey_from_secretkey(
     610        #[\SensitiveParameter]
     611        $secret_key
     612    ) {
    533613        return ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey($secret_key);
    534614    }
    … …  
    543623     * @throws TypeError
    544624     */
    545     function sodium_crypto_box_seal($message, $public_key)
    546     {
     625    function sodium_crypto_box_seal(
     626        #[\SensitiveParameter]
     627        $message,
     628        $public_key
     629    ) {
    547630        return ParagonIE_Sodium_Compat::crypto_box_seal($message, $public_key);
    548631    }
    … …  
    556639     * @throws SodiumException
    557640     */
    558     function sodium_crypto_box_seal_open($message, $key_pair)
    559     {
     641    function sodium_crypto_box_seal_open(
     642        $message,
     643        #[\SensitiveParameter]
     644        $key_pair
     645    ) {
    560646        try {
    561647            return ParagonIE_Sodium_Compat::crypto_box_seal_open($message, $key_pair);
    … …  
    576662     * @throws TypeError
    577663     */
    578     function sodium_crypto_box_secretkey($key_pair)
    579     {
     664    function sodium_crypto_box_secretkey(
     665        #[\SensitiveParameter]
     666        $key_pair
     667    ) {
    580668        return ParagonIE_Sodium_Compat::crypto_box_secretkey($key_pair);
    581669    }
    … …  
    589677     * @throws TypeError
    590678     */
    591     function sodium_crypto_box_seed_keypair($seed)
    592     {
     679    function sodium_crypto_box_seed_keypair(
     680        #[\SensitiveParameter]
     681        $seed
     682    ) {
    593683        return ParagonIE_Sodium_Compat::crypto_box_seed_keypair($seed);
    594684    }
    … …  
    604694     * @throws TypeError
    605695     */
    606     function sodium_crypto_generichash($message, $key = null, $length = 32)
    607     {
     696    function sodium_crypto_generichash(
     697        $message,
     698        #[\SensitiveParameter]
     699        $key = null,
     700        $length = 32
     701    ) {
    608702        return ParagonIE_Sodium_Compat::crypto_generichash($message, $key, $length);
    609703    }
    … …  
    632726     * @throws TypeError
    633727     */
    634     function sodium_crypto_generichash_init($key = null, $length = 32)
    635     {
     728    function sodium_crypto_generichash_init(
     729        #[\SensitiveParameter]
     730        $key = null,
     731        $length = 32
     732    ) {
    636733        return ParagonIE_Sodium_Compat::crypto_generichash_init($key, $length);
    637734    }
    … …  
    657754     * @throws TypeError
    658755     */
    659     function sodium_crypto_generichash_update(&$state, $message = '')
    660     {
     756    function sodium_crypto_generichash_update(
     757        #[\SensitiveParameter]
     758        &$state,
     759        $message = ''
     760    ) {
    661761        ParagonIE_Sodium_Compat::crypto_generichash_update($state, $message);
    662762    }
    … …  
    683783     * @throws Exception
    684784     */
    685     function sodium_crypto_kdf_derive_from_key($subkey_length, $subkey_id, $context, $key)
    686     {
     785    function sodium_crypto_kdf_derive_from_key(
     786        $subkey_length,
     787        $subkey_id,
     788        $context,
     789        #[\SensitiveParameter]
     790        $key
     791    ) {
    687792        return ParagonIE_Sodium_Compat::crypto_kdf_derive_from_key(
    688793            $subkey_length,
    … …  
    704809     * @throws TypeError
    705810     */
    706     function sodium_crypto_kx($my_secret, $their_public, $client_public, $server_public)
    707     {
     811    function sodium_crypto_kx(
     812        #[\SensitiveParameter]
     813        $my_secret,
     814        $their_public,
     815        $client_public,
     816        $server_public
     817    ) {
    708818        return ParagonIE_Sodium_Compat::crypto_kx(
    709819            $my_secret,
    … …  
    720830     * @throws Exception
    721831     */
    722     function sodium_crypto_kx_seed_keypair($seed)
    723     {
     832    function sodium_crypto_kx_seed_keypair(
     833        #[\SensitiveParameter]
     834        $seed
     835    ) {
    724836        return ParagonIE_Sodium_Compat::crypto_kx_seed_keypair($seed);
    725837    }
    … …  
    742854     * @throws SodiumException
    743855     */
    744     function sodium_crypto_kx_client_session_keys($client_key_pair, $server_key)
    745     {
     856    function sodium_crypto_kx_client_session_keys(
     857        #[\SensitiveParameter]
     858        $client_key_pair,
     859        $server_key
     860    ) {
    746861        return ParagonIE_Sodium_Compat::crypto_kx_client_session_keys($client_key_pair, $server_key);
    747862    }
    … …  
    754869     * @throws SodiumException
    755870     */
    756     function sodium_crypto_kx_server_session_keys($server_key_pair, $client_key)
    757     {
     871    function sodium_crypto_kx_server_session_keys(
     872        #[\SensitiveParameter]
     873        $server_key_pair,
     874        $client_key
     875    ) {
    758876        return ParagonIE_Sodium_Compat::crypto_kx_server_session_keys($server_key_pair, $client_key);
    759877    }
    … …  
    765883     * @throws Exception
    766884     */
    767     function sodium_crypto_kx_secretkey($key_pair)
    768     {
     885    function sodium_crypto_kx_secretkey(
     886        #[\SensitiveParameter]
     887        $key_pair
     888    ) {
    769889        return ParagonIE_Sodium_Compat::crypto_kx_secretkey($key_pair);
    770890    }
    … …  
    776896     * @throws Exception
    777897     */
    778     function sodium_crypto_kx_publickey($key_pair)
    779     {
     898    function sodium_crypto_kx_publickey(
     899        #[\SensitiveParameter]
     900        $key_pair
     901    ) {
    780902        return ParagonIE_Sodium_Compat::crypto_kx_publickey($key_pair);
    781903    }
    … …  
    794916     * @throws TypeError
    795917     */
    796     function sodium_crypto_pwhash($length, $passwd, $salt, $opslimit, $memlimit, $algo = null)
    797     {
     918    function sodium_crypto_pwhash(
     919        $length,
     920        #[\SensitiveParameter]
     921        $passwd,
     922        $salt,
     923        $opslimit,
     924        $memlimit,
     925        $algo = null
     926    ) {
    798927        return ParagonIE_Sodium_Compat::crypto_pwhash($length, $passwd, $salt, $opslimit, $memlimit, $algo);
    799928    }
    … …  
    809938     * @throws TypeError
    810939     */
    811     function sodium_crypto_pwhash_str($passwd, $opslimit, $memlimit)
    812     {
     940    function sodium_crypto_pwhash_str(
     941        #[\SensitiveParameter]
     942        $passwd,
     943        $opslimit,
     944        $memlimit
     945    ) {
    813946        return ParagonIE_Sodium_Compat::crypto_pwhash_str($passwd, $opslimit, $memlimit);
    814947    }
    … …  
    824957     * @throws SodiumException
    825958     */
    826     function sodium_crypto_pwhash_str_needs_rehash($hash, $opslimit, $memlimit)
    827     {
     959    function sodium_crypto_pwhash_str_needs_rehash(
     960        #[\SensitiveParameter]
     961        $hash,
     962        $opslimit,
     963        $memlimit
     964    ) {
    828965        return ParagonIE_Sodium_Compat::crypto_pwhash_str_needs_rehash($hash, $opslimit, $memlimit);
    829966    }
    … …  
    838975     * @throws TypeError
    839976     */
    840     function sodium_crypto_pwhash_str_verify($passwd, $hash)
    841     {
     977    function sodium_crypto_pwhash_str_verify(
     978        #[\SensitiveParameter]
     979        $passwd,
     980        #[\SensitiveParameter]
     981        $hash
     982    ) {
    842983        return ParagonIE_Sodium_Compat::crypto_pwhash_str_verify($passwd, $hash);
    843984    }
    … …  
    855996     * @throws TypeError
    856997     */
    857     function sodium_crypto_pwhash_scryptsalsa208sha256($length, $passwd, $salt, $opslimit, $memlimit)
    858     {
     998    function sodium_crypto_pwhash_scryptsalsa208sha256(
     999        $length,
     1000        #[\SensitiveParameter]
     1001        $passwd,
     1002        $salt,
     1003        $opslimit,
     1004        $memlimit
     1005    ) {
    8591006        return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256(
    8601007            $length,
    … …  
    8761023     * @throws TypeError
    8771024     */
    878     function sodium_crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit)
    879     {
     1025    function sodium_crypto_pwhash_scryptsalsa208sha256_str(
     1026        #[\SensitiveParameter]
     1027        $passwd,
     1028        $opslimit,
     1029        $memlimit
     1030    ) {
    8801031        return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit);
    8811032    }
    … …  
    8901041     * @throws TypeError
    8911042     */
    892     function sodium_crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash)
    893     {
     1043    function sodium_crypto_pwhash_scryptsalsa208sha256_str_verify(
     1044        #[\SensitiveParameter]
     1045        $passwd,
     1046        #[\SensitiveParameter]
     1047        $hash
     1048    ) {
    8941049        return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash);
    8951050    }
    … …  
    9041059     * @throws TypeError
    9051060     */
    906     function sodium_crypto_scalarmult($n, $p)
    907     {
     1061    function sodium_crypto_scalarmult(
     1062        #[\SensitiveParameter]
     1063        $n,
     1064        $p
     1065    ) {
    9081066        return ParagonIE_Sodium_Compat::crypto_scalarmult($n, $p);
    9091067    }
    … …  
    9171075     * @throws TypeError
    9181076     */
    919     function sodium_crypto_scalarmult_base($n)
    920     {
     1077    function sodium_crypto_scalarmult_base(
     1078        #[\SensitiveParameter]
     1079        $n
     1080    ) {
    9211081        return ParagonIE_Sodium_Compat::crypto_scalarmult_base($n);
    9221082    }
    … …  
    9321092     * @throws TypeError
    9331093     */
    934     function sodium_crypto_secretbox($message, $nonce, $key)
    935     {
     1094    function sodium_crypto_secretbox(
     1095        #[\SensitiveParameter]
     1096        $message,
     1097        $nonce,
     1098        #[\SensitiveParameter]
     1099        $key
     1100    ) {
    9361101        return ParagonIE_Sodium_Compat::crypto_secretbox($message, $nonce, $key);
    9371102    }
    … …  
    9561121     * @return string|bool
    9571122     */
    958     function sodium_crypto_secretbox_open($ciphertext, $nonce, $key)
    959     {
     1123    function sodium_crypto_secretbox_open(
     1124        $ciphertext,
     1125        $nonce,
     1126        #[\SensitiveParameter]
     1127        $key
     1128    ) {
    9601129        try {
    9611130            return ParagonIE_Sodium_Compat::crypto_secretbox_open($ciphertext, $nonce, $key);
    … …  
    9731142     * @throws SodiumException
    9741143     */
    975     function sodium_crypto_secretstream_xchacha20poly1305_init_push($key)
    976     {
     1144    function sodium_crypto_secretstream_xchacha20poly1305_init_push(
     1145        #[\SensitiveParameter]
     1146        $key
     1147    ) {
    9771148        return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_init_push($key);
    9781149    }
    … …  
    9881159     */
    9891160    function sodium_crypto_secretstream_xchacha20poly1305_push(
     1161        #[\SensitiveParameter]
    9901162        &$state,
     1163        #[\SensitiveParameter]
    9911164        $message,
    9921165        $additional_data = '',
    … …  
    10081181     * @throws Exception
    10091182     */
    1010     function sodium_crypto_secretstream_xchacha20poly1305_init_pull($header, $key)
    1011     {
     1183    function sodium_crypto_secretstream_xchacha20poly1305_init_pull(
     1184        $header,
     1185        #[\SensitiveParameter]
     1186        $key
     1187    ) {
    10121188        return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_init_pull($header, $key);
    10131189    }
    … …  
    10211197     * @throws SodiumException
    10221198     */
    1023     function sodium_crypto_secretstream_xchacha20poly1305_pull(&$state, $ciphertext, $additional_data = '')
    1024     {
     1199    function sodium_crypto_secretstream_xchacha20poly1305_pull(
     1200        #[\SensitiveParameter]
     1201        &$state,
     1202        $ciphertext,
     1203        $additional_data = ''
     1204    ) {
    10251205        return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_pull(
    10261206            $state,
    … …  
    10361216     * @throws SodiumException
    10371217     */
    1038     function sodium_crypto_secretstream_xchacha20poly1305_rekey(&$state)
    1039     {
     1218    function sodium_crypto_secretstream_xchacha20poly1305_rekey(
     1219        #[\SensitiveParameter]
     1220        &$state
     1221    ) {
    10401222        ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_rekey($state);
    10411223    }
    … …  
    10601242     * @throws TypeError
    10611243     */
    1062     function sodium_crypto_shorthash($message, $key = '')
    1063     {
     1244    function sodium_crypto_shorthash(
     1245        $message,
     1246        #[\SensitiveParameter]
     1247        $key = ''
     1248    ) {
    10641249        return ParagonIE_Sodium_Compat::crypto_shorthash($message, $key);
    10651250    }
    … …  
    10851270     * @throws TypeError
    10861271     */
    1087     function sodium_crypto_sign($message, $secret_key)
    1088     {
     1272    function sodium_crypto_sign(
     1273        $message,
     1274        #[\SensitiveParameter]
     1275        $secret_key
     1276    ) {
    10891277        return ParagonIE_Sodium_Compat::crypto_sign($message, $secret_key);
    10901278    }
    … …  
    10991287     * @throws TypeError
    11001288     */
    1101     function sodium_crypto_sign_detached($message, $secret_key)
    1102     {
     1289    function sodium_crypto_sign_detached(
     1290        $message,
     1291        #[\SensitiveParameter]
     1292        $secret_key
     1293    ) {
    11031294        return ParagonIE_Sodium_Compat::crypto_sign_detached($message, $secret_key);
    11041295    }
    … …  
    11131304     * @throws TypeError
    11141305     */
    1115     function sodium_crypto_sign_keypair_from_secretkey_and_publickey($secret_key, $public_key)
    1116     {
     1306    function sodium_crypto_sign_keypair_from_secretkey_and_publickey(
     1307        #[\SensitiveParameter]
     1308        $secret_key,
     1309        $public_key
     1310    ) {
    11171311        return ParagonIE_Sodium_Compat::crypto_sign_keypair_from_secretkey_and_publickey($secret_key, $public_key);
    11181312    }
    … …  
    11561350     * @throws TypeError
    11571351     */
    1158     function sodium_crypto_sign_publickey($key_pair)
    1159     {
     1352    function sodium_crypto_sign_publickey(
     1353        #[\SensitiveParameter]
     1354        $key_pair
     1355    ) {
    11601356        return ParagonIE_Sodium_Compat::crypto_sign_publickey($key_pair);
    11611357    }
    … …  
    11691365     * @throws TypeError
    11701366     */
    1171     function sodium_crypto_sign_publickey_from_secretkey($secret_key)
    1172     {
     1367    function sodium_crypto_sign_publickey_from_secretkey(
     1368        #[\SensitiveParameter]
     1369        $secret_key
     1370    ) {
    11731371        return ParagonIE_Sodium_Compat::crypto_sign_publickey_from_secretkey($secret_key);
    11741372    }
    … …  
    11821380     * @throws TypeError
    11831381     */
    1184     function sodium_crypto_sign_secretkey($key_pair)
    1185     {
     1382    function sodium_crypto_sign_secretkey(
     1383        #[\SensitiveParameter]
     1384        $key_pair
     1385    ) {
    11861386        return ParagonIE_Sodium_Compat::crypto_sign_secretkey($key_pair);
    11871387    }
    … …  
    11951395     * @throws TypeError
    11961396     */
    1197     function sodium_crypto_sign_seed_keypair($seed)
    1198     {
     1397    function sodium_crypto_sign_seed_keypair(
     1398        #[\SensitiveParameter]
     1399        $seed
     1400    ) {
    11991401        return ParagonIE_Sodium_Compat::crypto_sign_seed_keypair($seed);
    12001402    }
    … …  
    12361438     * @throws TypeError
    12371439     */
    1238     function sodium_crypto_sign_ed25519_sk_to_curve25519($secret_key)
    1239     {
     1440    function sodium_crypto_sign_ed25519_sk_to_curve25519(
     1441        #[\SensitiveParameter]
     1442        $secret_key
     1443    ) {
    12401444        return ParagonIE_Sodium_Compat::crypto_sign_ed25519_sk_to_curve25519($secret_key);
    12411445    }
    … …  
    12511455     * @throws TypeError
    12521456     */
    1253     function sodium_crypto_stream($length, $nonce, $key)
    1254     {
     1457    function sodium_crypto_stream(
     1458        $length,
     1459        $nonce,
     1460        #[\SensitiveParameter]
     1461        $key
     1462    ) {
    12551463        return ParagonIE_Sodium_Compat::crypto_stream($length, $nonce, $key);
    12561464    }
    … …  
    12771485     * @throws TypeError
    12781486     */
    1279     function sodium_crypto_stream_xor($message, $nonce, $key)
    1280     {
     1487    function sodium_crypto_stream_xor(
     1488        #[\SensitiveParameter]
     1489        $message,
     1490        $nonce,
     1491        #[\SensitiveParameter]
     1492        $key
     1493    ) {
    12811494        return ParagonIE_Sodium_Compat::crypto_stream_xor($message, $nonce, $key);
    12821495    }
    … …  
    12921505     * @throws TypeError
    12931506     */
    1294     function sodium_hex2bin($string, $ignore = '')
    1295     {
     1507    function sodium_hex2bin(
     1508        #[\SensitiveParameter]
     1509        $string,
     1510        $ignore = ''
     1511    ) {
    12961512        return ParagonIE_Sodium_Compat::hex2bin($string, $ignore);
    12971513    }
    … …  
    13051521     * @throws TypeError
    13061522     */
    1307     function sodium_increment(&$string)
    1308     {
     1523    function sodium_increment(
     1524        #[\SensitiveParameter]
     1525        &$string
     1526    ) {
    13091527        ParagonIE_Sodium_Compat::increment($string);
    13101528    }
    … …  
    13491567     * @throws TypeError
    13501568     */
    1351     function sodium_memcmp($string1, $string2)
    1352     {
     1569    function sodium_memcmp(
     1570        #[\SensitiveParameter]
     1571        $string1,
     1572        #[\SensitiveParameter]
     1573        $string2
     1574    ) {
    13531575        return ParagonIE_Sodium_Compat::memcmp($string1, $string2);
    13541576    }
    … …  
    13641586     * @psalm-suppress ReferenceConstraintViolation
    13651587     */
    1366     function sodium_memzero(&$string)
    1367     {
     1588    function sodium_memzero(
     1589        #[\SensitiveParameter]
     1590        &$string
     1591    ) {
    13681592        ParagonIE_Sodium_Compat::memzero($string);
    13691593    }
    … …  
    13781602     * @throws TypeError
    13791603     */
    1380     function sodium_pad($unpadded, $block_size)
    1381     {
     1604    function sodium_pad(
     1605        #[\SensitiveParameter]
     1606        $unpadded,
     1607        $block_size
     1608    ) {
    13821609        return ParagonIE_Sodium_Compat::pad($unpadded, $block_size, true);
    13831610    }
    … …  
    13921619     * @throws TypeError
    13931620     */
    1394     function sodium_unpad($padded, $block_size)
    1395     {
     1621    function sodium_unpad(
     1622        #[\SensitiveParameter]
     1623        $padded,
     1624        $block_size
     1625    ) {
    13961626        return ParagonIE_Sodium_Compat::unpad($padded, $block_size, true);
    13971627    }

  • trunk/src/wp-includes/sodium_compat/lib/ristretto255.php

    r54310 r58752  
    4848     * @throws SodiumException
    4949     */
    50     function sodium_crypto_core_ristretto255_add($p, $q)
    51     {
     50    function sodium_crypto_core_ristretto255_add(
     51        #[\SensitiveParameter]
     52        $p,
     53        #[\SensitiveParameter]
     54        $q
     55    ) {
    5256        return ParagonIE_Sodium_Compat::ristretto255_add($p, $q, true);
    5357    }
    … …  
    6165     * @throws SodiumException
    6266     */
    63     function sodium_crypto_core_ristretto255_from_hash($s)
    64     {
     67    function sodium_crypto_core_ristretto255_from_hash(
     68        #[\SensitiveParameter]
     69        $s
     70    ) {
    6571        return ParagonIE_Sodium_Compat::ristretto255_from_hash($s, true);
    6672    }
    … …  
    7480     * @throws SodiumException
    7581     */
    76     function sodium_crypto_core_ristretto255_is_valid_point($s)
    77     {
     82    function sodium_crypto_core_ristretto255_is_valid_point(
     83        #[\SensitiveParameter]
     84        $s
     85    ) {
    7886        return ParagonIE_Sodium_Compat::ristretto255_is_valid_point($s, true);
    7987    }
    … …  
    100108     * @throws SodiumException
    101109     */
    102     function sodium_crypto_core_ristretto255_scalar_add($x, $y)
    103     {
     110    function sodium_crypto_core_ristretto255_scalar_add(
     111        #[\SensitiveParameter]
     112        $x,
     113        #[\SensitiveParameter]
     114        $y
     115    ) {
    104116        return ParagonIE_Sodium_Compat::ristretto255_scalar_add($x, $y, true);
    105117    }
    … …  
    113125     * @throws SodiumException
    114126     */
    115     function sodium_crypto_core_ristretto255_scalar_complement($s)
    116     {
     127    function sodium_crypto_core_ristretto255_scalar_complement(
     128        #[\SensitiveParameter]
     129        $s
     130    ) {
    117131        return ParagonIE_Sodium_Compat::ristretto255_scalar_complement($s, true);
    118132    }
    … …  
    126140     * @throws SodiumException
    127141     */
    128     function sodium_crypto_core_ristretto255_scalar_invert($p)
    129     {
     142    function sodium_crypto_core_ristretto255_scalar_invert(
     143        #[\SensitiveParameter]
     144        $p
     145    ) {
    130146        return ParagonIE_Sodium_Compat::ristretto255_scalar_invert($p, true);
    131147    }
    … …  
    140156     * @throws SodiumException
    141157     */
    142     function sodium_crypto_core_ristretto255_scalar_mul($x, $y)
    143     {
     158    function sodium_crypto_core_ristretto255_scalar_mul(
     159        #[\SensitiveParameter]
     160        $x,
     161        #[\SensitiveParameter]
     162        $y
     163    ) {
    144164        return ParagonIE_Sodium_Compat::ristretto255_scalar_mul($x, $y, true);
    145165    }
    … …  
    153173     * @throws SodiumException
    154174     */
    155     function sodium_crypto_core_ristretto255_scalar_negate($s)
    156     {
     175    function sodium_crypto_core_ristretto255_scalar_negate(
     176        #[\SensitiveParameter]
     177        $s
     178    ) {
    157179        return ParagonIE_Sodium_Compat::ristretto255_scalar_negate($s, true);
    158180    }
    … …  
    178200     * @throws SodiumException
    179201     */
    180     function sodium_crypto_core_ristretto255_scalar_reduce($s)
    181     {
     202    function sodium_crypto_core_ristretto255_scalar_reduce(
     203        #[\SensitiveParameter]
     204        $s
     205    ) {
    182206        return ParagonIE_Sodium_Compat::ristretto255_scalar_reduce($s, true);
    183207    }
    … …  
    192216     * @throws SodiumException
    193217     */
    194     function sodium_crypto_core_ristretto255_scalar_sub($x, $y)
    195     {
     218    function sodium_crypto_core_ristretto255_scalar_sub(
     219        #[\SensitiveParameter]
     220        $x,
     221        #[\SensitiveParameter]
     222        $y
     223    ) {
    196224        return ParagonIE_Sodium_Compat::ristretto255_scalar_sub($x, $y, true);
    197225    }
    … …  
    206234     * @throws SodiumException
    207235     */
    208     function sodium_crypto_core_ristretto255_sub($p, $q)
    209     {
     236    function sodium_crypto_core_ristretto255_sub(
     237        #[\SensitiveParameter]
     238        $p,
     239        #[\SensitiveParameter]
     240        $q
     241    ) {
    210242        return ParagonIE_Sodium_Compat::ristretto255_sub($p, $q, true);
    211243    }
    … …  
    220252     * @throws TypeError
    221253     */
    222     function sodium_crypto_scalarmult_ristretto255($n, $p)
    223     {
     254    function sodium_crypto_scalarmult_ristretto255(
     255        #[\SensitiveParameter]
     256        $n,
     257        #[\SensitiveParameter]
     258        $p
     259    ) {
    224260        return ParagonIE_Sodium_Compat::scalarmult_ristretto255($n, $p, true);
    225261    }
    … …  
    233269     * @throws TypeError
    234270     */
    235     function sodium_crypto_scalarmult_ristretto255_base($n)
    236     {
     271    function sodium_crypto_scalarmult_ristretto255_base(
     272        #[\SensitiveParameter]
     273        $n
     274    ) {
    237275        return ParagonIE_Sodium_Compat::scalarmult_ristretto255_base($n, true);
    238276    }

  • trunk/src/wp-includes/sodium_compat/lib/sodium_compat.php

    r54310 r58752  
    2121     * @throws \TypeError
    2222     */
    23     function bin2hex($string)
    24     {
     23    function bin2hex(
     24        #[\SensitiveParameter]
     25        $string
     26    ) {
    2527        return ParagonIE_Sodium_Compat::bin2hex($string);
    2628    }
    … …  
    3537     * @throws \TypeError
    3638     */
    37     function compare($a, $b)
    38     {
     39    function compare(
     40        #[\SensitiveParameter]
     41        $a,
     42        #[\SensitiveParameter]
     43        $b
     44    ) {
    3945        return ParagonIE_Sodium_Compat::compare($a, $b);
    4046    }
    … …  
    4955     * @return string|bool
    5056     */
    51     function crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key)
    52     {
     57    function crypto_aead_aes256gcm_decrypt(
     58        $message,
     59        $assocData,
     60        $nonce,
     61        #[\SensitiveParameter]
     62        $key
     63    ) {
    5364        try {
    5465            return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key);
    … …  
    7182     * @throws \TypeError
    7283     */
    73     function crypto_aead_aes256gcm_encrypt($message, $assocData, $nonce, $key)
    74     {
     84    function crypto_aead_aes256gcm_encrypt(
     85        #[\SensitiveParameter]
     86        $message,
     87        $assocData,
     88        $nonce,
     89        #[\SensitiveParameter]
     90        $key
     91    ) {
    7592        return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt($message, $assocData, $nonce, $key);
    7693    }
    … …  
    95112     * @return string|bool
    96113     */
    97     function crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key)
    98     {
     114    function crypto_aead_chacha20poly1305_decrypt(
     115        $message,
     116        $assocData,
     117        $nonce,
     118        #[\SensitiveParameter]
     119        $key
     120    ) {
    99121        try {
    100122            return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key);
    … …  
    117139     * @throws \TypeError
    118140     */
    119     function crypto_aead_chacha20poly1305_encrypt($message, $assocData, $nonce, $key)
    120     {
     141    function crypto_aead_chacha20poly1305_encrypt(
     142        #[\SensitiveParameter]
     143        $message,
     144        $assocData,
     145        $nonce,
     146        #[\SensitiveParameter]
     147        $key
     148    ) {
    121149        return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt($message, $assocData, $nonce, $key);
    122150    }
    … …  
    131159     * @return string|bool
    132160     */
    133     function crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key)
    134     {
     161    function crypto_aead_chacha20poly1305_ietf_decrypt(
     162        $message,
     163        $assocData,
     164        $nonce,
     165        #[\SensitiveParameter]
     166        $key
     167    ) {
    135168        try {
    136169            return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key);
    … …  
    153186     * @throws \TypeError
    154187     */
    155     function crypto_aead_chacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key)
    156     {
     188    function crypto_aead_chacha20poly1305_ietf_encrypt(
     189        #[\SensitiveParameter]
     190        $message,
     191        $assocData,
     192        $nonce,
     193        #[\SensitiveParameter]
     194        $key
     195    ) {
    157196        return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key);
    158197    }
    … …  
    167206     * @throws \TypeError
    168207     */
    169     function crypto_auth($message, $key)
    170     {
     208    function crypto_auth(
     209        $message,
     210        #[\SensitiveParameter]
     211        $key
     212    ) {
    171213        return ParagonIE_Sodium_Compat::crypto_auth($message, $key);
    172214    }
    … …  
    182224     * @throws \TypeError
    183225     */
    184     function crypto_auth_verify($mac, $message, $key)
    185     {
     226    function crypto_auth_verify(
     227        $mac,
     228        $message,
     229        #[\SensitiveParameter]
     230        $key
     231    ) {
    186232        return ParagonIE_Sodium_Compat::crypto_auth_verify($mac, $message, $key);
    187233    }
    … …  
    197243     * @throws \TypeError
    198244     */
    199     function crypto_box($message, $nonce, $kp)
    200     {
     245    function crypto_box(
     246        #[\SensitiveParameter]
     247        $message,
     248        $nonce,
     249        #[\SensitiveParameter]
     250        $kp
     251    ) {
    201252        return ParagonIE_Sodium_Compat::crypto_box($message, $nonce, $kp);
    202253    }
    … …  
    223274     * @throws \TypeError
    224275     */
    225     function crypto_box_keypair_from_secretkey_and_publickey($sk, $pk)
    226     {
     276    function crypto_box_keypair_from_secretkey_and_publickey(
     277        #[\SensitiveParameter]
     278        $sk,
     279        $pk
     280    ) {
    227281        return ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey($sk, $pk);
    228282    }
    … …  
    236290     * @return string|bool
    237291     */
    238     function crypto_box_open($message, $nonce, $kp)
    239     {
     292    function crypto_box_open(
     293        #[\SensitiveParameter]
     294        $message,
     295        $nonce,
     296        #[\SensitiveParameter]
     297        $kp
     298    ) {
    240299        try {
    241300            return ParagonIE_Sodium_Compat::crypto_box_open($message, $nonce, $kp);
    … …  
    255314     * @throws \TypeError
    256315     */
    257     function crypto_box_publickey($keypair)
    258     {
     316    function crypto_box_publickey(
     317        #[\SensitiveParameter]
     318        $keypair
     319    ) {
    259320        return ParagonIE_Sodium_Compat::crypto_box_publickey($keypair);
    260321    }
    … …  
    268329     * @throws \TypeError
    269330     */
    270     function crypto_box_publickey_from_secretkey($sk)
    271     {
     331    function crypto_box_publickey_from_secretkey(
     332        #[\SensitiveParameter]
     333        $sk
     334    ) {
    272335        return ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey($sk);
    273336    }
    … …  
    282345     * @throws \TypeError
    283346     */
    284     function crypto_box_seal($message, $publicKey)
    285     {
     347    function crypto_box_seal(
     348        #[\SensitiveParameter]
     349        $message,
     350        $publicKey
     351    ) {
    286352        return ParagonIE_Sodium_Compat::crypto_box_seal($message, $publicKey);
    287353    }
    … …  
    294360     * @return string|bool
    295361     */
    296     function crypto_box_seal_open($message, $kp)
    297     {
     362    function crypto_box_seal_open(
     363        $message,
     364        #[\SensitiveParameter]
     365        $kp
     366    ) {
    298367        try {
    299368            return ParagonIE_Sodium_Compat::crypto_box_seal_open($message, $kp);
    … …  
    313382     * @throws \TypeError
    314383     */
    315     function crypto_box_secretkey($keypair)
    316     {
     384    function crypto_box_secretkey(
     385        #[\SensitiveParameter]
     386        $keypair
     387    ) {
    317388        return ParagonIE_Sodium_Compat::crypto_box_secretkey($keypair);
    318389    }
    … …  
    328399     * @throws \TypeError
    329400     */
    330     function crypto_generichash($message, $key = null, $outLen = 32)
    331     {
     401    function crypto_generichash(
     402        $message,
     403        #[\SensitiveParameter]
     404        $key = null,
     405        $outLen = 32
     406    ) {
    332407        return ParagonIE_Sodium_Compat::crypto_generichash($message, $key, $outLen);
    333408    }
    … …  
    342417     * @throws \TypeError
    343418     */
    344     function crypto_generichash_final(&$ctx, $outputLength = 32)
    345     {
     419    function crypto_generichash_final(
     420        #[\SensitiveParameter]
     421        &$ctx,
     422        $outputLength = 32
     423    ) {
    346424        return ParagonIE_Sodium_Compat::crypto_generichash_final($ctx, $outputLength);
    347425    }
    … …  
    356434     * @throws \TypeError
    357435     */
    358     function crypto_generichash_init($key = null, $outLen = 32)
    359     {
     436    function crypto_generichash_init(
     437        #[\SensitiveParameter]
     438        $key = null,
     439        $outLen = 32
     440    ) {
    360441        return ParagonIE_Sodium_Compat::crypto_generichash_init($key, $outLen);
    361442    }
    … …  
    370451     * @throws \TypeError
    371452     */
    372     function crypto_generichash_update(&$ctx, $message = '')
    373     {
     453    function crypto_generichash_update(
     454        #[\SensitiveParameter]
     455        &$ctx,
     456        $message = ''
     457    ) {
    374458        ParagonIE_Sodium_Compat::crypto_generichash_update($ctx, $message);
    375459    }
    … …  
    386470     * @throws \TypeError
    387471     */
    388     function crypto_kx($my_secret, $their_public, $client_public, $server_public)
    389     {
     472    function crypto_kx(
     473        #[\SensitiveParameter]
     474        $my_secret,
     475        $their_public,
     476        $client_public,
     477        $server_public
     478    ) {
    390479        return ParagonIE_Sodium_Compat::crypto_kx(
    391480            $my_secret,
    … …  
    409498     * @throws \TypeError
    410499     */
    411     function crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit)
    412     {
     500    function crypto_pwhash(
     501        $outlen,
     502        #[\SensitiveParameter]
     503        $passwd,
     504        $salt,
     505        $opslimit,
     506        $memlimit
     507    ) {
    413508        return ParagonIE_Sodium_Compat::crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit);
    414509    }
    … …  
    424519     * @throws \TypeError
    425520     */
    426     function crypto_pwhash_str($passwd, $opslimit, $memlimit)
    427     {
     521    function crypto_pwhash_str(
     522        #[\SensitiveParameter]
     523        $passwd,
     524        $opslimit,
     525        $memlimit
     526    ) {
    428527        return ParagonIE_Sodium_Compat::crypto_pwhash_str($passwd, $opslimit, $memlimit);
    429528    }
    … …  
    438537     * @throws \TypeError
    439538     */
    440     function crypto_pwhash_str_verify($passwd, $hash)
    441     {
     539    function crypto_pwhash_str_verify(
     540        #[\SensitiveParameter]
     541        $passwd,
     542        #[\SensitiveParameter]
     543        $hash
     544    ) {
    442545        return ParagonIE_Sodium_Compat::crypto_pwhash_str_verify($passwd, $hash);
    443546    }
    … …  
    455558     * @throws \TypeError
    456559     */
    457     function crypto_pwhash_scryptsalsa208sha256($outlen, $passwd, $salt, $opslimit, $memlimit)
    458     {
     560    function crypto_pwhash_scryptsalsa208sha256(
     561        $outlen,
     562        #[\SensitiveParameter]
     563        $passwd,
     564        #[\SensitiveParameter]
     565        $salt,
     566        $opslimit,
     567        $memlimit
     568    ) {
    459569        return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256($outlen, $passwd, $salt, $opslimit, $memlimit);
    460570    }
    … …  
    470580     * @throws \TypeError
    471581     */
    472     function crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit)
    473     {
     582    function crypto_pwhash_scryptsalsa208sha256_str(
     583        #[\SensitiveParameter]
     584        $passwd,
     585        $opslimit,
     586        $memlimit
     587    ) {
    474588        return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit);
    475589    }
    … …  
    484598     * @throws \TypeError
    485599     */
    486     function crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash)
    487     {
     600    function crypto_pwhash_scryptsalsa208sha256_str_verify(
     601        #[\SensitiveParameter]
     602        $passwd,
     603        #[\SensitiveParameter]
     604        $hash
     605    ) {
    488606        return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash);
    489607    }
    … …  
    498616     * @throws \TypeError
    499617     */
    500     function crypto_scalarmult($n, $p)
    501     {
     618    function crypto_scalarmult(
     619        #[\SensitiveParameter]
     620        $n,
     621        $p
     622    ) {
    502623        return ParagonIE_Sodium_Compat::crypto_scalarmult($n, $p);
    503624    }
    … …  
    511632     * @throws \TypeError
    512633     */
    513     function crypto_scalarmult_base($n)
    514     {
     634    function crypto_scalarmult_base(
     635        #[\SensitiveParameter]
     636        $n
     637    ) {
    515638        return ParagonIE_Sodium_Compat::crypto_scalarmult_base($n);
    516639    }
    … …  
    526649     * @throws \TypeError
    527650     */
    528     function crypto_secretbox($message, $nonce, $key)
    529     {
     651    function crypto_secretbox(
     652        #[\SensitiveParameter]
     653        $message,
     654        $nonce,
     655        #[\SensitiveParameter]
     656        $key
     657    ) {
    530658        return ParagonIE_Sodium_Compat::crypto_secretbox($message, $nonce, $key);
    531659    }
    … …  
    539667     * @return string|bool
    540668     */
    541     function crypto_secretbox_open($message, $nonce, $key)
    542     {
     669    function crypto_secretbox_open(
     670        $message,
     671        $nonce,
     672        #[\SensitiveParameter]
     673        $key
     674    ) {
    543675        try {
    544676            return ParagonIE_Sodium_Compat::crypto_secretbox_open($message, $nonce, $key);
    … …  
    559691     * @throws \TypeError
    560692     */
    561     function crypto_shorthash($message, $key = '')
    562     {
     693    function crypto_shorthash(
     694        $message,
     695        #[\SensitiveParameter]
     696        $key = ''
     697    ) {
    563698        return ParagonIE_Sodium_Compat::crypto_shorthash($message, $key);
    564699    }
    … …  
    573708     * @throws \TypeError
    574709     */
    575     function crypto_sign($message, $sk)
    576     {
     710    function crypto_sign(
     711        $message,
     712        #[\SensitiveParameter]
     713        $sk
     714    ) {
    577715        return ParagonIE_Sodium_Compat::crypto_sign($message, $sk);
    578716    }
    … …  
    587725     * @throws \TypeError
    588726     */
    589     function crypto_sign_detached($message, $sk)
    590     {
     727    function crypto_sign_detached(
     728        $message,
     729        #[\SensitiveParameter]
     730        $sk
     731    ) {
    591732        return ParagonIE_Sodium_Compat::crypto_sign_detached($message, $sk);
    592733    }
    … …  
    630771     * @throws \TypeError
    631772     */
    632     function crypto_sign_publickey($keypair)
    633     {
     773    function crypto_sign_publickey(
     774        #[\SensitiveParameter]
     775        $keypair
     776    ) {
    634777        return ParagonIE_Sodium_Compat::crypto_sign_publickey($keypair);
    635778    }
    … …  
    643786     * @throws \TypeError
    644787     */
    645     function crypto_sign_publickey_from_secretkey($sk)
    646     {
     788    function crypto_sign_publickey_from_secretkey(
     789        #[\SensitiveParameter]
     790        $sk
     791    ) {
    647792        return ParagonIE_Sodium_Compat::crypto_sign_publickey_from_secretkey($sk);
    648793    }
    … …  
    656801     * @throws \TypeError
    657802     */
    658     function crypto_sign_secretkey($keypair)
    659     {
     803    function crypto_sign_secretkey(
     804        #[\SensitiveParameter]
     805        $keypair
     806    ) {
    660807        return ParagonIE_Sodium_Compat::crypto_sign_secretkey($keypair);
    661808    }
    … …  
    669816     * @throws \TypeError
    670817     */
    671     function crypto_sign_seed_keypair($seed)
    672     {
     818    function crypto_sign_seed_keypair(
     819        #[\SensitiveParameter]
     820        $seed
     821    ) {
    673822        return ParagonIE_Sodium_Compat::crypto_sign_seed_keypair($seed);
    674823    }
    … …  
    710859     * @throws \TypeError
    711860     */
    712     function crypto_sign_ed25519_sk_to_curve25519($sk)
    713     {
     861    function crypto_sign_ed25519_sk_to_curve25519(
     862        #[\SensitiveParameter]
     863        $sk
     864    ) {
    714865        return ParagonIE_Sodium_Compat::crypto_sign_ed25519_sk_to_curve25519($sk);
    715866    }
    … …  
    725876     * @throws \TypeError
    726877     */
    727     function crypto_stream($len, $nonce, $key)
    728     {
     878    function crypto_stream(
     879        $len,
     880        $nonce,
     881        #[\SensitiveParameter]
     882        $key
     883    ) {
    729884        return ParagonIE_Sodium_Compat::crypto_stream($len, $nonce, $key);
    730885    }
    … …  
    740895     * @throws \TypeError
    741896     */
    742     function crypto_stream_xor($message, $nonce, $key)
    743     {
     897    function crypto_stream_xor(
     898        #[\SensitiveParameter]
     899        $message,
     900        $nonce,
     901        #[\SensitiveParameter]
     902        $key
     903    ) {
    744904        return ParagonIE_Sodium_Compat::crypto_stream_xor($message, $nonce, $key);
    745905    }
    … …  
    753913     * @throws \TypeError
    754914     */
    755     function hex2bin($string)
    756     {
     915    function hex2bin(
     916        #[\SensitiveParameter]
     917        $string
     918    ) {
    757919        return ParagonIE_Sodium_Compat::hex2bin($string);
    758920    }
    … …  
    767929     * @throws \TypeError
    768930     */
    769     function memcmp($a, $b)
    770     {
     931    function memcmp(
     932        #[\SensitiveParameter]
     933        $a,
     934        #[\SensitiveParameter]
     935        $b
     936    ) {
    771937        return ParagonIE_Sodium_Compat::memcmp($a, $b);
    772938    }
    … …  
    784950     * @psalm-suppress ReferenceConstraintViolation
    785951     */
    786     function memzero(&$str)
    787     {
     952    function memzero(
     953        #[\SensitiveParameter]
     954        &$str
     955    ) {
    788956        ParagonIE_Sodium_Compat::memzero($str);
    789957    }

  • trunk/src/wp-includes/sodium_compat/lib/stream-xchacha20.php

    r54150 r58752  
    1111     * @throws TypeError
    1212     */
    13     function sodium_crypto_stream_xchacha20($len, $nonce, $key)
    14     {
     13    function sodium_crypto_stream_xchacha20(
     14        $len,
     15        $nonce,
     16        #[\SensitiveParameter]
     17        $key
     18    ) {
    1519        return ParagonIE_Sodium_Compat::crypto_stream_xchacha20($len, $nonce, $key, true);
    1620    }
    … …  
    3741     * @throws TypeError
    3842     */
    39     function sodium_crypto_stream_xchacha20_xor($message, $nonce, $key)
    40     {
     43    function sodium_crypto_stream_xchacha20_xor(
     44        #[\SensitiveParameter]
     45        $message,
     46        $nonce,
     47        #[\SensitiveParameter]
     48        $key
     49    ) {
    4150        return ParagonIE_Sodium_Compat::crypto_stream_xchacha20_xor($message, $nonce, $key, true);
    4251    }
    … …  
    5362     * @throws TypeError
    5463     */
    55     function sodium_crypto_stream_xchacha20_xor_ic($message, $nonce, $counter, $key)
    56     {
     64    function sodium_crypto_stream_xchacha20_xor_ic(
     65        #[\SensitiveParameter]
     66        $message,
     67        $nonce,
     68        $counter,
     69        #[\SensitiveParameter]
     70        $key
     71    ) {
    5772        return ParagonIE_Sodium_Compat::crypto_stream_xchacha20_xor_ic($message, $nonce, $counter, $key, true);
    5873    }

  • trunk/src/wp-includes/sodium_compat/src/Compat.php

    r54310 r58752  
    6060    const CRYPTO_AEAD_AES256GCM_NPUBBYTES = 12;
    6161    const CRYPTO_AEAD_AES256GCM_ABYTES = 16;
     62    const CRYPTO_AEAD_AEGIS128L_KEYBYTES = 16;
     63    const CRYPTO_AEAD_AEGIS128L_NSECBYTES = 0;
     64    const CRYPTO_AEAD_AEGIS128L_NPUBBYTES = 16;
     65    const CRYPTO_AEAD_AEGIS128L_ABYTES = 32;
     66    const CRYPTO_AEAD_AEGIS256_KEYBYTES = 32;
     67    const CRYPTO_AEAD_AEGIS256_NSECBYTES = 0;
     68    const CRYPTO_AEAD_AEGIS256_NPUBBYTES = 32;
     69    const CRYPTO_AEAD_AEGIS256_ABYTES = 32;
    6270    const CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES = 32;
    6371    const CRYPTO_AEAD_CHACHA20POLY1305_NSECBYTES = 0;
    … …  
    156164     * @throws SodiumException
    157165     */
    158     public static function add(&$val, $addv)
    159     {
     166    public static function add(
     167        #[\SensitiveParameter]
     168        &$val,
     169        #[\SensitiveParameter]
     170        $addv
     171    ) {
    160172        $val_len = ParagonIE_Sodium_Core_Util::strlen($val);
    161173        $addv_len = ParagonIE_Sodium_Core_Util::strlen($addv);
    … …  
    182194     * @throws SodiumException
    183195     */
    184     public static function base642bin($encoded, $variant, $ignore = '')
    185     {
     196    public static function base642bin(
     197        #[\SensitiveParameter]
     198        $encoded,
     199        $variant,
     200        $ignore = ''
     201    ) {
    186202        /* Type checks: */
    187203        ParagonIE_Sodium_Core_Util::declareScalarType($encoded, 'string', 1);
    … …  
    225241     * @throws SodiumException
    226242     */
    227     public static function bin2base64($decoded, $variant)
    228     {
     243    public static function bin2base64(
     244        #[\SensitiveParameter]
     245        $decoded,
     246        $variant
     247    ) {
    229248        /* Type checks: */
    230249        ParagonIE_Sodium_Core_Util::declareScalarType($decoded, 'string', 1);
    … …  
    258277     * @psalm-suppress MixedArgument
    259278     */
    260     public static function bin2hex($string)
    261     {
     279    public static function bin2hex(
     280        #[\SensitiveParameter]
     281        $string
     282    ) {
    262283        /* Type checks: */
    263284        ParagonIE_Sodium_Core_Util::declareScalarType($string, 'string', 1);
    … …  
    285306     * @psalm-suppress MixedArgument
    286307     */
    287     public static function compare($left, $right)
    288     {
     308    public static function compare(
     309        #[\SensitiveParameter]
     310        $left,
     311        #[\SensitiveParameter]
     312        $right
     313    ) {
    289314        /* Type checks: */
    290315        ParagonIE_Sodium_Core_Util::declareScalarType($left, 'string', 1);
    … …  
    298323        }
    299324        return ParagonIE_Sodium_Core_Util::compare($left, $right);
     325    }
     326
     327    /**
     328     * Authenticated Encryption with Associated Data: Decryption
     329     *
     330     * Algorithm:
     331     *     AEGIS-128L
     332     *
     333     * @param string $ciphertext Encrypted message (with MAC appended)
     334     * @param string $assocData  Authenticated Associated Data (unencrypted)
     335     * @param string $nonce      Number to be used only Once; must be 32 bytes
     336     * @param string $key        Encryption key
     337     *
     338     * @return string            The original plaintext message
     339     * @throws SodiumException
     340     * @throws TypeError
     341     * @psalm-suppress MixedArgument
     342     * @psalm-suppress MixedInferredReturnType
     343     * @psalm-suppress MixedReturnStatement
     344     */
     345    public static function crypto_aead_aegis128l_decrypt(
     346        $ciphertext = '',
     347        $assocData = '',
     348        $nonce = '',
     349        #[\SensitiveParameter]
     350        $key = ''
     351    ) {
     352        ParagonIE_Sodium_Core_Util::declareScalarType($ciphertext, 'string', 1);
     353        ParagonIE_Sodium_Core_Util::declareScalarType($assocData, 'string', 2);
     354        ParagonIE_Sodium_Core_Util::declareScalarType($nonce, 'string', 3);
     355        ParagonIE_Sodium_Core_Util::declareScalarType($key, 'string', 4);
     356
     357        /* Input validation: */
     358        if (ParagonIE_Sodium_Core_Util::strlen($nonce) !== self::CRYPTO_AEAD_AEGIS128L_NPUBBYTES) {
     359            throw new SodiumException('Nonce must be CRYPTO_AEAD_AEGIS_128L_NPUBBYTES long');
     360        }
     361        if (ParagonIE_Sodium_Core_Util::strlen($key) !== self::CRYPTO_AEAD_AEGIS128L_KEYBYTES) {
     362            throw new SodiumException('Key must be CRYPTO_AEAD_AEGIS128L_KEYBYTES long');
     363        }
     364        $ct_length = ParagonIE_Sodium_Core_Util::strlen($ciphertext);
     365        if ($ct_length < self::CRYPTO_AEAD_AEGIS128L_ABYTES) {
     366            throw new SodiumException('Message must be at least CRYPTO_AEAD_AEGIS128L_ABYTES long');
     367        }
     368
     369        $ct = ParagonIE_Sodium_Core_Util::substr(
     370            $ciphertext,
     371            0,
     372            $ct_length - self::CRYPTO_AEAD_AEGIS128L_ABYTES
     373        );
     374        $tag = ParagonIE_Sodium_Core_Util::substr(
     375            $ciphertext,
     376            $ct_length - self::CRYPTO_AEAD_AEGIS128L_ABYTES,
     377            self::CRYPTO_AEAD_AEGIS128L_ABYTES
     378        );
     379        return ParagonIE_Sodium_Core_AEGIS128L::decrypt($ct, $tag, $assocData, $key, $nonce);
     380    }
     381
     382    /**
     383     * Authenticated Encryption with Associated Data: Encryption
     384     *
     385     * Algorithm:
     386     *     AEGIS-128L
     387     *
     388     * @param string $plaintext Message to be encrypted
     389     * @param string $assocData Authenticated Associated Data (unencrypted)
     390     * @param string $nonce     Number to be used only Once; must be 32 bytes
     391     * @param string $key       Encryption key
     392     *
     393     * @return string           Ciphertext with 32-byte authentication tag appended
     394     * @throws SodiumException
     395     * @throws TypeError
     396     * @psalm-suppress MixedArgument
     397     */
     398    public static function crypto_aead_aegis128l_encrypt(
     399        #[\SensitiveParameter]
     400        $plaintext = '',
     401        $assocData = '',
     402        $nonce = '',
     403        #[\SensitiveParameter]
     404        $key = ''
     405    ) {
     406        ParagonIE_Sodium_Core_Util::declareScalarType($plaintext, 'string', 1);
     407        ParagonIE_Sodium_Core_Util::declareScalarType($assocData, 'string', 2);
     408        ParagonIE_Sodium_Core_Util::declareScalarType($nonce, 'string', 3);
     409        ParagonIE_Sodium_Core_Util::declareScalarType($key, 'string', 4);
     410
     411        /* Input validation: */
     412        if (ParagonIE_Sodium_Core_Util::strlen($nonce) !== self::CRYPTO_AEAD_AEGIS128L_NPUBBYTES) {
     413            throw new SodiumException('Nonce must be CRYPTO_AEAD_AEGIS128L_KEYBYTES long');
     414        }
     415        if (ParagonIE_Sodium_Core_Util::strlen($key) !== self::CRYPTO_AEAD_AEGIS128L_KEYBYTES) {
     416            throw new SodiumException('Key must be CRYPTO_AEAD_AEGIS128L_KEYBYTES long');
     417        }
     418
     419        list($ct, $tag) = ParagonIE_Sodium_Core_AEGIS128L::encrypt($plaintext, $assocData, $key, $nonce);
     420        return $ct . $tag;
     421    }
     422
     423    /**
     424     * Return a secure random key for use with the AEGIS-128L
     425     * symmetric AEAD interface.
     426     *
     427     * @return string
     428     * @throws Exception
     429     * @throws Error
     430     */
     431    public static function crypto_aead_aegis128l_keygen()
     432    {
     433        return random_bytes(self::CRYPTO_AEAD_AEGIS128L_KEYBYTES);
     434    }
     435
     436    /**
     437     * Authenticated Encryption with Associated Data: Decryption
     438     *
     439     * Algorithm:
     440     *     AEGIS-256
     441     *
     442     * @param string $ciphertext Encrypted message (with MAC appended)
     443     * @param string $assocData  Authenticated Associated Data (unencrypted)
     444     * @param string $nonce      Number to be used only Once; must be 32 bytes
     445     * @param string $key        Encryption key
     446     *
     447     * @return string            The original plaintext message
     448     * @throws SodiumException
     449     * @throws TypeError
     450     * @psalm-suppress MixedArgument
     451     * @psalm-suppress MixedInferredReturnType
     452     * @psalm-suppress MixedReturnStatement
     453     */
     454    public static function crypto_aead_aegis256_decrypt(
     455        $ciphertext = '',
     456        $assocData = '',
     457        $nonce = '',
     458        #[\SensitiveParameter]
     459        $key = ''
     460    ) {
     461        ParagonIE_Sodium_Core_Util::declareScalarType($ciphertext, 'string', 1);
     462        ParagonIE_Sodium_Core_Util::declareScalarType($assocData, 'string', 2);
     463        ParagonIE_Sodium_Core_Util::declareScalarType($nonce, 'string', 3);
     464        ParagonIE_Sodium_Core_Util::declareScalarType($key, 'string', 4);
     465
     466        /* Input validation: */
     467        if (ParagonIE_Sodium_Core_Util::strlen($nonce) !== self::CRYPTO_AEAD_AEGIS256_NPUBBYTES) {
     468            throw new SodiumException('Nonce must be CRYPTO_AEAD_AEGIS256_NPUBBYTES long');
     469        }
     470        if (ParagonIE_Sodium_Core_Util::strlen($key) !== self::CRYPTO_AEAD_AEGIS256_KEYBYTES) {
     471            throw new SodiumException('Key must be CRYPTO_AEAD_AEGIS256_KEYBYTES long');
     472        }
     473        $ct_length = ParagonIE_Sodium_Core_Util::strlen($ciphertext);
     474        if ($ct_length < self::CRYPTO_AEAD_AEGIS256_ABYTES) {
     475            throw new SodiumException('Message must be at least CRYPTO_AEAD_AEGIS256_ABYTES long');
     476        }
     477
     478        $ct = ParagonIE_Sodium_Core_Util::substr(
     479            $ciphertext,
     480            0,
     481            $ct_length - self::CRYPTO_AEAD_AEGIS256_ABYTES
     482        );
     483        $tag = ParagonIE_Sodium_Core_Util::substr(
     484            $ciphertext,
     485            $ct_length - self::CRYPTO_AEAD_AEGIS256_ABYTES,
     486            self::CRYPTO_AEAD_AEGIS256_ABYTES
     487        );
     488        return ParagonIE_Sodium_Core_AEGIS256::decrypt($ct, $tag, $assocData, $key, $nonce);
     489    }
     490
     491    /**
     492     * Authenticated Encryption with Associated Data: Encryption
     493     *
     494     * Algorithm:
     495     *     AEGIS-256
     496     *
     497     * @param string $plaintext Message to be encrypted
     498     * @param string $assocData Authenticated Associated Data (unencrypted)
     499     * @param string $nonce Number to be used only Once; must be 32 bytes
     500     * @param string $key Encryption key
     501     *
     502     * @return string           Ciphertext with 32-byte authentication tag appended
     503     * @throws SodiumException
     504     * @throws TypeError
     505     * @psalm-suppress MixedArgument
     506     */
     507    public static function crypto_aead_aegis256_encrypt(
     508        #[\SensitiveParameter]
     509        $plaintext = '',
     510        $assocData = '',
     511        $nonce = '',
     512        #[\SensitiveParameter]
     513        $key = ''
     514    ) {
     515        ParagonIE_Sodium_Core_Util::declareScalarType($plaintext, 'string', 1);
     516        ParagonIE_Sodium_Core_Util::declareScalarType($assocData, 'string', 2);
     517        ParagonIE_Sodium_Core_Util::declareScalarType($nonce, 'string', 3);
     518        ParagonIE_Sodium_Core_Util::declareScalarType($key, 'string', 4);
     519
     520        /* Input validation: */
     521        if (ParagonIE_Sodium_Core_Util::strlen($nonce) !== self::CRYPTO_AEAD_AEGIS256_NPUBBYTES) {
     522            throw new SodiumException('Nonce must be CRYPTO_AEAD_AEGIS128L_KEYBYTES long');
     523        }
     524        if (ParagonIE_Sodium_Core_Util::strlen($key) !== self::CRYPTO_AEAD_AEGIS256_KEYBYTES) {
     525            throw new SodiumException('Key must be CRYPTO_AEAD_AEGIS128L_KEYBYTES long');
     526        }
     527
     528        list($ct, $tag) = ParagonIE_Sodium_Core_AEGIS256::encrypt($plaintext, $assocData, $key, $nonce);
     529        return $ct . $tag;
     530    }
     531
     532    /**
     533     * Return a secure random key for use with the AEGIS-256
     534     * symmetric AEAD interface.
     535     *
     536     * @return string
     537     * @throws Exception
     538     * @throws Error
     539     */
     540    public static function crypto_aead_aegis256_keygen()
     541    {
     542        return random_bytes(self::CRYPTO_AEAD_AEGIS256_KEYBYTES);
    300543    }
    301544
    … …  
    352595        $assocData = '',
    353596        $nonce = '',
     597        #[\SensitiveParameter]
    354598        $key = ''
    355599    ) {
    … …  
    409653     */
    410654    public static function crypto_aead_aes256gcm_encrypt(
     655        #[\SensitiveParameter]
    411656        $plaintext = '',
    412657        $assocData = '',
    413658        $nonce = '',
     659        #[\SensitiveParameter]
    414660        $key = ''
    415661    ) {
    … …  
    485731        $assocData = '',
    486732        $nonce = '',
     733        #[\SensitiveParameter]
    487734        $key = ''
    488735    ) {
    … …  
    562809     */
    563810    public static function crypto_aead_chacha20poly1305_encrypt(
     811        #[\SensitiveParameter]
    564812        $plaintext = '',
    565813        $assocData = '',
    566814        $nonce = '',
     815        #[\SensitiveParameter]
    567816        $key = ''
    568817    ) {
    … …  
    639888        $assocData = '',
    640889        $nonce = '',
     890        #[\SensitiveParameter]
    641891        $key = ''
    642892    ) {
    … …  
    729979     */
    730980    public static function crypto_aead_chacha20poly1305_ietf_encrypt(
     981        #[\SensitiveParameter]
    731982        $plaintext = '',
    732983        $assocData = '',
    733984        $nonce = '',
     985        #[\SensitiveParameter]
    734986        $key = ''
    735987    ) {
    … …  
    8201072        $assocData = '',
    8211073        $nonce = '',
     1074        #[\SensitiveParameter]
    8221075        $key = '',
    8231076        $dontFallback = false
    … …  
    8921145     */
    8931146    public static function crypto_aead_xchacha20poly1305_ietf_encrypt(
     1147        #[\SensitiveParameter]
    8941148        $plaintext = '',
    8951149        $assocData = '',
    8961150        $nonce = '',
     1151        #[\SensitiveParameter]
    8971152        $key = '',
    8981153        $dontFallback = false
    … …  
    9721227     * @psalm-suppress MixedArgument
    9731228     */
    974     public static function crypto_auth($message, $key)
    975     {
     1229    public static function crypto_auth(
     1230        $message,
     1231        #[\SensitiveParameter]
     1232        $key
     1233    ) {
    9761234        /* Type checks: */
    9771235        ParagonIE_Sodium_Core_Util::declareScalarType($message, 'string', 1);
    … …  
    10171275     * @psalm-suppress MixedArgument
    10181276     */
    1019     public static function crypto_auth_verify($mac, $message, $key)
    1020     {
     1277    public static function crypto_auth_verify(
     1278        $mac,
     1279        $message,
     1280        #[\SensitiveParameter]
     1281        $key
     1282    ) {
    10211283        /* Type checks: */
    10221284        ParagonIE_Sodium_Core_Util::declareScalarType($mac, 'string', 1);
    … …  
    10611323     * @psalm-suppress MixedArgument
    10621324     */
    1063     public static function crypto_box($plaintext, $nonce, $keypair)
    1064     {
     1325    public static function crypto_box(
     1326        $plaintext,
     1327        $nonce,
     1328        #[\SensitiveParameter]
     1329        $keypair
     1330    ) {
    10651331        /* Type checks: */
    10661332        ParagonIE_Sodium_Core_Util::declareScalarType($plaintext, 'string', 1);
    … …  
    11051371     * @psalm-suppress MixedArgument
    11061372     */
    1107     public static function crypto_box_seal($plaintext, $publicKey)
    1108     {
     1373    public static function crypto_box_seal(
     1374        #[\SensitiveParameter]
     1375        $plaintext,
     1376        $publicKey
     1377    ) {
    11091378        /* Type checks: */
    11101379        ParagonIE_Sodium_Core_Util::declareScalarType($plaintext, 'string', 1);
    … …  
    11431412     * @psalm-suppress MixedReturnStatement
    11441413     */
    1145     public static function crypto_box_seal_open($ciphertext, $keypair)
    1146     {
     1414    public static function crypto_box_seal_open(
     1415        $ciphertext,
     1416        #[\SensitiveParameter]
     1417        $keypair
     1418    ) {
    11471419        /* Type checks: */
    11481420        ParagonIE_Sodium_Core_Util::declareScalarType($ciphertext, 'string', 1);
    … …  
    12061478     * @psalm-suppress MixedArgument
    12071479     */
    1208     public static function crypto_box_keypair_from_secretkey_and_publickey($secretKey, $publicKey)
    1209     {
     1480    public static function crypto_box_keypair_from_secretkey_and_publickey(
     1481        #[\SensitiveParameter]
     1482        $secretKey,
     1483        $publicKey
     1484    ) {
    12101485        /* Type checks: */
    12111486        ParagonIE_Sodium_Core_Util::declareScalarType($secretKey, 'string', 1);
    … …  
    12451520     * @psalm-suppress MixedReturnStatement
    12461521     */
    1247     public static function crypto_box_open($ciphertext, $nonce, $keypair)
    1248     {
     1522    public static function crypto_box_open(
     1523        $ciphertext,
     1524        $nonce,
     1525        #[\SensitiveParameter]
     1526        $keypair
     1527    ) {
    12491528        /* Type checks: */
    12501529        ParagonIE_Sodium_Core_Util::declareScalarType($ciphertext, 'string', 1);
    … …  
    12881567     * @psalm-suppress MixedArgument
    12891568     */
    1290     public static function crypto_box_publickey($keypair)
    1291     {
     1569    public static function crypto_box_publickey(
     1570        #[\SensitiveParameter]
     1571        $keypair
     1572    ) {
    12921573        /* Type checks: */
    12931574        ParagonIE_Sodium_Core_Util::declareScalarType($keypair, 'string', 1);
    … …  
    13191600     * @psalm-suppress MixedArgument
    13201601     */
    1321     public static function crypto_box_publickey_from_secretkey($secretKey)
    1322     {
     1602    public static function crypto_box_publickey_from_secretkey(
     1603        #[\SensitiveParameter]
     1604        $secretKey
     1605    ) {
    13231606        /* Type checks: */
    13241607        ParagonIE_Sodium_Core_Util::declareScalarType($secretKey, 'string', 1);
    … …  
    13501633     * @psalm-suppress MixedArgument
    13511634     */
    1352     public static function crypto_box_secretkey($keypair)
    1353     {
     1635    public static function crypto_box_secretkey(
     1636        #[\SensitiveParameter]
     1637        $keypair
     1638    ) {
    13541639        /* Type checks: */
    13551640        ParagonIE_Sodium_Core_Util::declareScalarType($keypair, 'string', 1);
    … …  
    13821667     * @psalm-suppress UndefinedFunction
    13831668     */
    1384     public static function crypto_box_seed_keypair($seed)
    1385     {
     1669    public static function crypto_box_seed_keypair(
     1670        #[\SensitiveParameter]
     1671        $seed
     1672    ) {
    13861673        /* Type checks: */
    13871674        ParagonIE_Sodium_Core_Util::declareScalarType($seed, 'string', 1);
    … …  
    14121699     * @psalm-suppress MixedArgument
    14131700     */
    1414     public static function crypto_generichash($message, $key = '', $length = self::CRYPTO_GENERICHASH_BYTES)
    1415     {
     1701    public static function crypto_generichash(
     1702        $message,
     1703        #[\SensitiveParameter]
     1704        $key = '',
     1705        $length = self::CRYPTO_GENERICHASH_BYTES
     1706    ) {
    14161707        /* Type checks: */
    14171708        ParagonIE_Sodium_Core_Util::declareScalarType($message, 'string', 1);
    … …  
    14561747     * @psalm-suppress ConflictingReferenceConstraint
    14571748     */
    1458     public static function crypto_generichash_final(&$ctx, $length = self::CRYPTO_GENERICHASH_BYTES)
    1459     {
     1749    public static function crypto_generichash_final(
     1750        #[\SensitiveParameter]
     1751        &$ctx,
     1752        $length = self::CRYPTO_GENERICHASH_BYTES
     1753    ) {
    14601754        /* Type checks: */
    14611755        ParagonIE_Sodium_Core_Util::declareScalarType($ctx, 'string', 1);
    … …  
    15011795     * @psalm-suppress MixedArgument
    15021796     */
    1503     public static function crypto_generichash_init($key = '', $length = self::CRYPTO_GENERICHASH_BYTES)
    1504     {
     1797    public static function crypto_generichash_init(
     1798        #[\SensitiveParameter]
     1799        $key = '',
     1800        $length = self::CRYPTO_GENERICHASH_BYTES
     1801    ) {
    15051802        /* Type checks: */
    15061803        if (is_null($key)) {
    … …  
    15461843     */
    15471844    public static function crypto_generichash_init_salt_personal(
     1845        #[\SensitiveParameter]
    15481846        $key = '',
    15491847        $length = self::CRYPTO_GENERICHASH_BYTES,
    … …  
    15921890     * @psalm-suppress ReferenceConstraintViolation
    15931891     */
    1594     public static function crypto_generichash_update(&$ctx, $message)
    1595     {
     1892    public static function crypto_generichash_update(
     1893        #[\SensitiveParameter]
     1894        &$ctx,
     1895        $message
     1896    ) {
    15961897        /* Type checks: */
    15971898        ParagonIE_Sodium_Core_Util::declareScalarType($ctx, 'string', 1);
    … …  
    16361937        $subkey_id,
    16371938        $context,
     1939        #[\SensitiveParameter]
    16381940        $key
    16391941    ) {
    … …  
    17132015     * @psalm-suppress MixedArgument
    17142016     */
    1715     public static function crypto_kx($my_secret, $their_public, $client_public, $server_public, $dontFallback = false)
    1716     {
     2017    public static function crypto_kx(
     2018        #[\SensitiveParameter]
     2019        $my_secret,
     2020        $their_public,
     2021        $client_public,
     2022        $server_public,
     2023        $dontFallback = false
     2024    ) {
    17172025        /* Type checks: */
    17182026        ParagonIE_Sodium_Core_Util::declareScalarType($my_secret, 'string', 1);
    … …  
    17752083     * @throws SodiumException
    17762084     */
    1777     public static function crypto_kx_seed_keypair($seed)
    1778     {
     2085    public static function crypto_kx_seed_keypair(
     2086        #[\SensitiveParameter]
     2087        $seed
     2088    ) {
    17792089        ParagonIE_Sodium_Core_Util::declareScalarType($seed, 'string', 1);
    17802090
    … …  
    18072117     * @throws SodiumException
    18082118     */
    1809     public static function crypto_kx_client_session_keys($keypair, $serverPublicKey)
    1810     {
     2119    public static function crypto_kx_client_session_keys(
     2120        #[\SensitiveParameter]
     2121        $keypair,
     2122        $serverPublicKey
     2123    ) {
    18112124        ParagonIE_Sodium_Core_Util::declareScalarType($keypair, 'string', 1);
    18122125        ParagonIE_Sodium_Core_Util::declareScalarType($serverPublicKey, 'string', 2);
    … …  
    18492162     * @throws SodiumException
    18502163     */
    1851     public static function crypto_kx_server_session_keys($keypair, $clientPublicKey)
    1852     {
     2164    public static function crypto_kx_server_session_keys(
     2165        #[\SensitiveParameter]
     2166        $keypair,
     2167        $clientPublicKey
     2168    ) {
    18532169        ParagonIE_Sodium_Core_Util::declareScalarType($keypair, 'string', 1);
    18542170        ParagonIE_Sodium_Core_Util::declareScalarType($clientPublicKey, 'string', 2);
    … …  
    18902206     * @throws SodiumException
    18912207     */
    1892     public static function crypto_kx_secretkey($kp)
    1893     {
     2208    public static function crypto_kx_secretkey(
     2209        #[\SensitiveParameter]
     2210        $kp
     2211    ) {
    18942212        return ParagonIE_Sodium_Core_Util::substr(
    18952213            $kp,
    … …  
    19252243     * @psalm-suppress MixedArgument
    19262244     */
    1927     public static function crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit, $alg = null)
    1928     {
     2245    public static function crypto_pwhash(
     2246        $outlen,
     2247        #[\SensitiveParameter]
     2248        $passwd,
     2249        $salt,
     2250        $opslimit,
     2251        $memlimit,
     2252        $alg = null
     2253    ) {
    19292254        ParagonIE_Sodium_Core_Util::declareScalarType($outlen, 'int', 1);
    19302255        ParagonIE_Sodium_Core_Util::declareScalarType($passwd, 'string', 2);
    … …  
    19772302     * @psalm-suppress MixedArgument
    19782303     */
    1979     public static function crypto_pwhash_str($passwd, $opslimit, $memlimit)
    1980     {
     2304    public static function crypto_pwhash_str(
     2305        #[\SensitiveParameter]
     2306        $passwd,
     2307        $opslimit,
     2308        $memlimit
     2309    ) {
    19812310        ParagonIE_Sodium_Core_Util::declareScalarType($passwd, 'string', 1);
    19822311        ParagonIE_Sodium_Core_Util::declareScalarType($opslimit, 'int', 2);
    … …  
    20042333     * @throws SodiumException
    20052334     */
    2006     public static function crypto_pwhash_str_needs_rehash($hash, $opslimit, $memlimit)
    2007     {
     2335    public static function crypto_pwhash_str_needs_rehash(
     2336        #[\SensitiveParameter]
     2337        $hash,
     2338        $opslimit,
     2339        $memlimit
     2340    ) {
    20082341        ParagonIE_Sodium_Core_Util::declareScalarType($hash, 'string', 1);
    20092342        ParagonIE_Sodium_Core_Util::declareScalarType($opslimit, 'int', 2);
    … …  
    20332366     * @psalm-suppress MixedArgument
    20342367     */
    2035     public static function crypto_pwhash_str_verify($passwd, $hash)
    2036     {
     2368    public static function crypto_pwhash_str_verify(
     2369        #[\SensitiveParameter]
     2370        $passwd,
     2371        #[\SensitiveParameter]
     2372        $hash
     2373    ) {
    20372374        ParagonIE_Sodium_Core_Util::declareScalarType($passwd, 'string', 1);
    20382375        ParagonIE_Sodium_Core_Util::declareScalarType($hash, 'string', 2);
    … …  
    20602397     * @throws TypeError
    20612398     */
    2062     public static function crypto_pwhash_scryptsalsa208sha256($outlen, $passwd, $salt, $opslimit, $memlimit)
    2063     {
     2399    public static function crypto_pwhash_scryptsalsa208sha256(
     2400        $outlen,
     2401        #[\SensitiveParameter]
     2402        $passwd,
     2403        $salt,
     2404        $opslimit,
     2405        $memlimit
     2406    ) {
    20642407        ParagonIE_Sodium_Core_Util::declareScalarType($outlen, 'int', 1);
    20652408        ParagonIE_Sodium_Core_Util::declareScalarType($passwd, 'string', 2);
    … …  
    21202463     * @throws TypeError
    21212464     */
    2122     public static function crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit)
    2123     {
     2465    public static function crypto_pwhash_scryptsalsa208sha256_str(
     2466        #[\SensitiveParameter]
     2467        $passwd,
     2468        $opslimit,
     2469        $memlimit
     2470    ) {
    21242471        ParagonIE_Sodium_Core_Util::declareScalarType($passwd, 'string', 1);
    21252472        ParagonIE_Sodium_Core_Util::declareScalarType($opslimit, 'int', 2);
    … …  
    21542501     * @throws TypeError
    21552502     */
    2156     public static function crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash)
    2157     {
     2503    public static function crypto_pwhash_scryptsalsa208sha256_str_verify(
     2504        #[\SensitiveParameter]
     2505        $passwd,
     2506        #[\SensitiveParameter]
     2507        $hash
     2508    ) {
    21582509        ParagonIE_Sodium_Core_Util::declareScalarType($passwd, 'string', 1);
    21592510        ParagonIE_Sodium_Core_Util::declareScalarType($hash, 'string', 2);
    … …  
    21912542     * @psalm-suppress MixedArgument
    21922543     */
    2193     public static function crypto_scalarmult($secretKey, $publicKey)
    2194     {
     2544    public static function crypto_scalarmult(
     2545        #[\SensitiveParameter]
     2546        $secretKey,
     2547        $publicKey
     2548    ) {
    21952549        /* Type checks: */
    21962550        ParagonIE_Sodium_Core_Util::declareScalarType($secretKey, 'string', 1);
    … …  
    22352589     * @psalm-suppress MixedArgument
    22362590     */
    2237     public static function crypto_scalarmult_base($secretKey)
    2238     {
     2591    public static function crypto_scalarmult_base(
     2592        #[\SensitiveParameter]
     2593        $secretKey
     2594    ) {
    22392595        /* Type checks: */
    22402596        ParagonIE_Sodium_Core_Util::declareScalarType($secretKey, 'string', 1);
    … …  
    22732629     * @psalm-suppress MixedArgument
    22742630     */
    2275     public static function crypto_secretbox($plaintext, $nonce, $key)
    2276     {
     2631    public static function crypto_secretbox(
     2632        #[\SensitiveParameter]
     2633        $plaintext,
     2634        $nonce,
     2635        #[\SensitiveParameter]
     2636        $key
     2637    ) {
    22772638        /* Type checks: */
    22782639        ParagonIE_Sodium_Core_Util::declareScalarType($plaintext, 'string', 1);
    … …  
    23132674     * @psalm-suppress MixedReturnStatement
    23142675     */
    2315     public static function crypto_secretbox_open($ciphertext, $nonce, $key)
    2316     {
     2676    public static function crypto_secretbox_open(
     2677        $ciphertext,
     2678        $nonce,
     2679        #[\SensitiveParameter]
     2680        $key
     2681    ) {
    23172682        /* Type checks: */
    23182683        ParagonIE_Sodium_Core_Util::declareScalarType($ciphertext, 'string', 1);
    … …  
    23992764     * @psalm-suppress MixedArgument
    24002765     */
    2401     public static function crypto_secretbox_xchacha20poly1305_open($ciphertext, $nonce, $key)
    2402     {
     2766    public static function crypto_secretbox_xchacha20poly1305_open(
     2767        $ciphertext,
     2768        $nonce,
     2769        #[\SensitiveParameter]
     2770        $key
     2771    ) {
    24032772        /* Type checks: */
    24042773        ParagonIE_Sodium_Core_Util::declareScalarType($ciphertext, 'string', 1);
    … …  
    24262795     * @throws SodiumException
    24272796     */
    2428     public static function crypto_secretstream_xchacha20poly1305_init_push($key)
    2429     {
     2797    public static function crypto_secretstream_xchacha20poly1305_init_push(
     2798        #[\SensitiveParameter]
     2799        $key
     2800    ) {
    24302801        if (PHP_INT_SIZE === 4) {
    24312802            return ParagonIE_Sodium_Crypto32::secretstream_xchacha20poly1305_init_push($key);
    … …  
    24402811     * @throws Exception
    24412812     */
    2442     public static function crypto_secretstream_xchacha20poly1305_init_pull($header, $key)
    2443     {
     2813    public static function crypto_secretstream_xchacha20poly1305_init_pull(
     2814        $header,
     2815        #[\SensitiveParameter]
     2816        $key
     2817    ) {
    24442818        if (ParagonIE_Sodium_Core_Util::strlen($header) < self::CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_HEADERBYTES) {
    24452819            throw new SodiumException(
    … …  
    24612835     * @throws SodiumException
    24622836     */
    2463     public static function crypto_secretstream_xchacha20poly1305_push(&$state, $msg, $aad = '', $tag = 0)
    2464     {
     2837    public static function crypto_secretstream_xchacha20poly1305_push(
     2838        #[\SensitiveParameter]
     2839        &$state,
     2840        #[\SensitiveParameter]
     2841        $msg,
     2842        $aad = '',
     2843        $tag = 0
     2844    ) {
    24652845        if (PHP_INT_SIZE === 4) {
    24662846            return ParagonIE_Sodium_Crypto32::secretstream_xchacha20poly1305_push(
    … …  
    24862866     * @throws SodiumException
    24872867     */
    2488     public static function crypto_secretstream_xchacha20poly1305_pull(&$state, $msg, $aad = '')
    2489     {
     2868    public static function crypto_secretstream_xchacha20poly1305_pull(
     2869        #[\SensitiveParameter]
     2870        &$state,
     2871        $msg,
     2872        $aad = ''
     2873    ) {
    24902874        if (PHP_INT_SIZE === 4) {
    24912875            return ParagonIE_Sodium_Crypto32::secretstream_xchacha20poly1305_pull(
    … …  
    25162900     * @throws SodiumException
    25172901     */
    2518     public static function crypto_secretstream_xchacha20poly1305_rekey(&$state)
    2519     {
     2902    public static function crypto_secretstream_xchacha20poly1305_rekey(
     2903        #[\SensitiveParameter]
     2904        &$state
     2905    ) {
    25202906        if (PHP_INT_SIZE === 4) {
    25212907            ParagonIE_Sodium_Crypto32::secretstream_xchacha20poly1305_rekey($state);
    … …  
    25372923     * @psalm-suppress MixedReturnStatement
    25382924     */
    2539     public static function crypto_shorthash($message, $key)
    2540     {
     2925    public static function crypto_shorthash(
     2926        $message,
     2927        #[\SensitiveParameter]
     2928        $key
     2929    ) {
    25412930        /* Type checks: */
    25422931        ParagonIE_Sodium_Core_Util::declareScalarType($message, 'string', 1);
    … …  
    25872976     * @psalm-suppress MixedReturnStatement
    25882977     */
    2589     public static function crypto_sign($message, $secretKey)
    2590     {
     2978    public static function crypto_sign(
     2979        $message,
     2980        #[\SensitiveParameter]
     2981        $secretKey
     2982    ) {
    25912983        /* Type checks: */
    25922984        ParagonIE_Sodium_Core_Util::declareScalarType($message, 'string', 1);
    … …  
    26233015     * @psalm-suppress MixedReturnStatement
    26243016     */
    2625     public static function crypto_sign_open($signedMessage, $publicKey)
    2626     {
     3017    public static function crypto_sign_open(
     3018        $signedMessage,
     3019        $publicKey
     3020    ) {
    26273021        /* Type checks: */
    26283022        ParagonIE_Sodium_Core_Util::declareScalarType($signedMessage, 'string', 1);
    … …  
    26803074     * @throws SodiumException
    26813075     */
    2682     public static function crypto_sign_keypair_from_secretkey_and_publickey($sk, $pk)
    2683     {
     3076    public static function crypto_sign_keypair_from_secretkey_and_publickey(
     3077        #[\SensitiveParameter]
     3078        $sk,
     3079        $pk
     3080    )  {
    26843081        ParagonIE_Sodium_Core_Util::declareScalarType($sk, 'string', 1);
    26853082        ParagonIE_Sodium_Core_Util::declareScalarType($pk, 'string', 1);
    … …  
    27093106     * @psalm-suppress MixedArgument
    27103107     */
    2711     public static function crypto_sign_seed_keypair($seed)
    2712     {
     3108    public static function crypto_sign_seed_keypair(
     3109        #[\SensitiveParameter]
     3110        $seed
     3111    ) {
    27133112        ParagonIE_Sodium_Core_Util::declareScalarType($seed, 'string', 1);
    27143113
    … …  
    27383137     * @psalm-suppress MixedArgument
    27393138     */
    2740     public static function crypto_sign_publickey($keypair)
    2741     {
     3139    public static function crypto_sign_publickey(
     3140        #[\SensitiveParameter]
     3141        $keypair
     3142    ) {
    27423143        /* Type checks: */
    27433144        ParagonIE_Sodium_Core_Util::declareScalarType($keypair, 'string', 1);
    … …  
    27693170     * @psalm-suppress MixedArgument
    27703171     */
    2771     public static function crypto_sign_publickey_from_secretkey($secretKey)
    2772     {
     3172    public static function crypto_sign_publickey_from_secretkey(
     3173        #[\SensitiveParameter]
     3174        $secretKey
     3175    ) {
    27733176        /* Type checks: */
    27743177        ParagonIE_Sodium_Core_Util::declareScalarType($secretKey, 'string', 1);
    … …  
    28003203     * @psalm-suppress MixedArgument
    28013204     */
    2802     public static function crypto_sign_secretkey($keypair)
    2803     {
     3205    public static function crypto_sign_secretkey(
     3206        #[\SensitiveParameter]
     3207        $keypair
     3208    ) {
    28043209        /* Type checks: */
    28053210        ParagonIE_Sodium_Core_Util::declareScalarType($keypair, 'string', 1);
    … …  
    28343239     * @psalm-suppress MixedArgument
    28353240     */
    2836     public static function crypto_sign_detached($message, $secretKey)
    2837     {
     3241    public static function crypto_sign_detached(
     3242        $message,
     3243        #[\SensitiveParameter]
     3244        $secretKey
     3245    ) {
    28383246        /* Type checks: */
    28393247        ParagonIE_Sodium_Core_Util::declareScalarType($message, 'string', 1);
    … …  
    29423350     * @psalm-suppress MixedArgument
    29433351     */
    2944     public static function crypto_sign_ed25519_sk_to_curve25519($sk)
    2945     {
     3352    public static function crypto_sign_ed25519_sk_to_curve25519(
     3353        #[\SensitiveParameter]
     3354        $sk
     3355    ) {
    29463356        /* Type checks: */
    29473357        ParagonIE_Sodium_Core_Util::declareScalarType($sk, 'string', 1);
    … …  
    29843394     * @psalm-suppress MixedArgument
    29853395     */
    2986     public static function crypto_stream($len, $nonce, $key)
    2987     {
     3396    public static function crypto_stream(
     3397        $len,
     3398        $nonce,
     3399        #[\SensitiveParameter]
     3400        $key
     3401    ) {
    29883402        /* Type checks: */
    29893403        ParagonIE_Sodium_Core_Util::declareScalarType($len, 'int', 1);
    … …  
    30313445     * @psalm-suppress MixedArgument
    30323446     */
    3033     public static function crypto_stream_xor($message, $nonce, $key)
    3034     {
     3447    public static function crypto_stream_xor(
     3448        #[\SensitiveParameter]
     3449        $message,
     3450        $nonce,
     3451        #[\SensitiveParameter]
     3452        $key
     3453    ) {
    30353454        /* Type checks: */
    30363455        ParagonIE_Sodium_Core_Util::declareScalarType($message, 'string', 1);
    … …  
    30863505     * @psalm-suppress MixedArgument
    30873506     */
    3088     public static function crypto_stream_xchacha20($len, $nonce, $key, $dontFallback = false)
    3089     {
     3507    public static function crypto_stream_xchacha20(
     3508        $len,
     3509        $nonce,
     3510        #[\SensitiveParameter]
     3511        $key,
     3512        $dontFallback = false
     3513    ) {
    30903514        /* Type checks: */
    30913515        ParagonIE_Sodium_Core_Util::declareScalarType($len, 'int', 1);
    … …  
    31313555     * @psalm-suppress MixedArgument
    31323556     */
    3133     public static function crypto_stream_xchacha20_xor($message, $nonce, $key, $dontFallback = false)
    3134     {
     3557    public static function crypto_stream_xchacha20_xor(
     3558        #[\SensitiveParameter]
     3559        $message,
     3560        $nonce,
     3561        #[\SensitiveParameter]
     3562        $key,
     3563        $dontFallback = false
     3564    ) {
    31353565        /* Type checks: */
    31363566        ParagonIE_Sodium_Core_Util::declareScalarType($message, 'string', 1);
    … …  
    31773607     * @psalm-suppress MixedArgument
    31783608     */
    3179     public static function crypto_stream_xchacha20_xor_ic($message, $nonce, $counter, $key, $dontFallback = false)
    3180     {
     3609    public static function crypto_stream_xchacha20_xor_ic(
     3610        #[\SensitiveParameter]
     3611        $message,
     3612        $nonce,
     3613        $counter,
     3614        #[\SensitiveParameter]
     3615        $key,
     3616        $dontFallback = false
     3617    ) {
    31813618        /* Type checks: */
    31823619        ParagonIE_Sodium_Core_Util::declareScalarType($message, 'string', 1);
    … …  
    32273664     * @psalm-suppress MixedArgument
    32283665     */
    3229     public static function hex2bin($string, $ignore = '')
    3230     {
     3666    public static function hex2bin(
     3667        #[\SensitiveParameter]
     3668        $string,
     3669        $ignore = ''
     3670    ) {
    32313671        /* Type checks: */
    32323672        ParagonIE_Sodium_Core_Util::declareScalarType($string, 'string', 1);
    … …  
    32543694     * @psalm-suppress MixedArgument
    32553695     */
    3256     public static function increment(&$var)
    3257     {
     3696    public static function increment(
     3697        #[\SensitiveParameter]
     3698        &$var
     3699    ) {
    32583700        /* Type checks: */
    32593701        ParagonIE_Sodium_Core_Util::declareScalarType($var, 'string', 1);
    … …  
    32883730     * @throws SodiumException
    32893731     */
    3290     public static function is_zero($str)
    3291     {
     3732    public static function is_zero(
     3733        #[\SensitiveParameter]
     3734        $str
     3735    ) {
    32923736        $d = 0;
    32933737        for ($i = 0; $i < 32; ++$i) {
    … …  
    33433787     * @psalm-suppress MixedArgument
    33443788     */
    3345     public static function memcmp($left, $right)
    3346     {
     3789    public static function memcmp(
     3790        #[\SensitiveParameter]
     3791        $left,
     3792        #[\SensitiveParameter]
     3793        $right
     3794    ) {
    33473795        /* Type checks: */
    33483796        ParagonIE_Sodium_Core_Util::declareScalarType($left, 'string', 1);
    … …  
    33723820     * @psalm-suppress TooFewArguments
    33733821     */
    3374     public static function memzero(&$var)
    3375     {
     3822    public static function memzero(
     3823        #[\SensitiveParameter]
     3824        &$var
     3825    ) {
    33763826        /* Type checks: */
    33773827        ParagonIE_Sodium_Core_Util::declareScalarType($var, 'string', 1);
    … …  
    34033853     * @throws SodiumException
    34043854     */
    3405     public static function pad($unpadded, $blockSize, $dontFallback = false)
    3406     {
     3855    public static function pad(
     3856        #[\SensitiveParameter]
     3857        $unpadded,
     3858        $blockSize,
     3859        $dontFallback = false
     3860    ) {
    34073861        /* Type checks: */
    34083862        ParagonIE_Sodium_Core_Util::declareScalarType($unpadded, 'string', 1);
    … …  
    34893943     * @throws SodiumException
    34903944     */
    3491     public static function unpad($padded, $blockSize, $dontFallback = false)
    3492     {
     3945    public static function unpad(
     3946        #[\SensitiveParameter]
     3947        $padded,
     3948        $blockSize,
     3949        $dontFallback = false
     3950    ) {
    34933951        /* Type checks: */
    34943952        ParagonIE_Sodium_Core_Util::declareScalarType($padded, 'string', 1);
    … …  
    36444102     * @throws SodiumException
    36454103     */
    3646     public static function ristretto255_is_valid_point($p, $dontFallback = false)
    3647     {
     4104    public static function ristretto255_is_valid_point(
     4105        #[\SensitiveParameter]
     4106        $p,
     4107        $dontFallback = false
     4108    ) {
    36484109        if (self::useNewSodiumAPI() && !$dontFallback) {
    36494110            return sodium_crypto_core_ristretto255_is_valid_point($p);
    … …  
    36684129     * @throws SodiumException
    36694130     */
    3670     public static function ristretto255_add($p, $q, $dontFallback = false)
    3671     {
     4131    public static function ristretto255_add(
     4132        #[\SensitiveParameter]
     4133        $p,
     4134        #[\SensitiveParameter]
     4135        $q,
     4136        $dontFallback = false
     4137    ) {
    36724138        if (self::useNewSodiumAPI() && !$dontFallback) {
    36734139            return sodium_crypto_core_ristretto255_add($p, $q);
    … …  
    36834149     * @throws SodiumException
    36844150     */
    3685     public static function ristretto255_sub($p, $q, $dontFallback = false)
    3686     {
     4151    public static function ristretto255_sub(
     4152        #[\SensitiveParameter]
     4153        $p,
     4154        #[\SensitiveParameter]
     4155        $q,
     4156        $dontFallback = false
     4157    ) {
    36874158        if (self::useNewSodiumAPI() && !$dontFallback) {
    36884159            return sodium_crypto_core_ristretto255_sub($p, $q);
    … …  
    36984169     * @throws SodiumException
    36994170     */
    3700     public static function ristretto255_from_hash($r, $dontFallback = false)
    3701     {
     4171    public static function ristretto255_from_hash(
     4172        #[\SensitiveParameter]
     4173        $r,
     4174        $dontFallback = false
     4175    ) {
    37024176        if (self::useNewSodiumAPI() && !$dontFallback) {
    37034177            return sodium_crypto_core_ristretto255_from_hash($r);
    … …  
    37404214     * @throws SodiumException
    37414215     */
    3742     public static function ristretto255_scalar_invert($s, $dontFallback = false)
    3743     {
     4216    public static function ristretto255_scalar_invert(
     4217        #[\SensitiveParameter]
     4218        $s,
     4219        $dontFallback = false
     4220    ) {
    37444221        if (self::useNewSodiumAPI() && !$dontFallback) {
    37454222            return sodium_crypto_core_ristretto255_scalar_invert($s);
    … …  
    37534230     * @throws SodiumException
    37544231     */
    3755     public static function ristretto255_scalar_negate($s, $dontFallback = false)
    3756     {
     4232    public static function ristretto255_scalar_negate(
     4233        #[\SensitiveParameter]
     4234        $s,
     4235        $dontFallback = false
     4236    ) {
    37574237        if (self::useNewSodiumAPI() && !$dontFallback) {
    37584238            return sodium_crypto_core_ristretto255_scalar_negate($s);
    … …  
    37674247     * @throws SodiumException
    37684248     */
    3769     public static function ristretto255_scalar_complement($s, $dontFallback = false)
    3770     {
     4249    public static function ristretto255_scalar_complement(
     4250        #[\SensitiveParameter]
     4251        $s,
     4252        $dontFallback = false
     4253    ) {
    37714254        if (self::useNewSodiumAPI() && !$dontFallback) {
    37724255            return sodium_crypto_core_ristretto255_scalar_complement($s);
    … …  
    37824265     * @throws SodiumException
    37834266     */
    3784     public static function ristretto255_scalar_add($x, $y, $dontFallback = false)
    3785     {
     4267    public static function ristretto255_scalar_add(
     4268        #[\SensitiveParameter]
     4269        $x,
     4270        #[\SensitiveParameter]
     4271        $y,
     4272        $dontFallback = false
     4273    ) {
    37864274        if (self::useNewSodiumAPI() && !$dontFallback) {
    37874275            return sodium_crypto_core_ristretto255_scalar_add($x, $y);
    … …  
    37974285     * @throws SodiumException
    37984286     */
    3799     public static function ristretto255_scalar_sub($x, $y, $dontFallback = false)
    3800     {
     4287    public static function ristretto255_scalar_sub(
     4288        #[\SensitiveParameter]
     4289        $x,
     4290        #[\SensitiveParameter]
     4291        $y,
     4292        $dontFallback = false
     4293    ) {
    38014294        if (self::useNewSodiumAPI() && !$dontFallback) {
    38024295            return sodium_crypto_core_ristretto255_scalar_sub($x, $y);
    … …  
    38124305     * @throws SodiumException
    38134306     */
    3814     public static function ristretto255_scalar_mul($x, $y, $dontFallback = false)
    3815     {
     4307    public static function ristretto255_scalar_mul(
     4308        #[\SensitiveParameter]
     4309        $x,
     4310        #[\SensitiveParameter]
     4311        $y,
     4312        $dontFallback = false
     4313    ) {
    38164314        if (self::useNewSodiumAPI() && !$dontFallback) {
    38174315            return sodium_crypto_core_ristretto255_scalar_mul($x, $y);
    … …  
    38274325     * @throws SodiumException
    38284326     */
    3829     public static function scalarmult_ristretto255($n, $p, $dontFallback = false)
    3830     {
     4327    public static function scalarmult_ristretto255(
     4328        #[\SensitiveParameter]
     4329        $n,
     4330        #[\SensitiveParameter]
     4331        $p,
     4332        $dontFallback = false
     4333    ) {
    38314334        if (self::useNewSodiumAPI() && !$dontFallback) {
    38324335            return sodium_crypto_scalarmult_ristretto255($n, $p);
    … …  
    38424345     * @throws SodiumException
    38434346     */
    3844     public static function scalarmult_ristretto255_base($n, $dontFallback = false)
    3845     {
     4347    public static function scalarmult_ristretto255_base(
     4348        #[\SensitiveParameter]
     4349        $n,
     4350        $dontFallback = false
     4351    ) {
    38464352        if (self::useNewSodiumAPI() && !$dontFallback) {
    38474353            return sodium_crypto_scalarmult_ristretto255_base($n);
    … …  
    38564362     * @throws SodiumException
    38574363     */
    3858     public static function ristretto255_scalar_reduce($s, $dontFallback = false)
    3859     {
     4364    public static function ristretto255_scalar_reduce(
     4365        #[\SensitiveParameter]
     4366        $s,
     4367        $dontFallback = false
     4368    ) {
    38604369        if (self::useNewSodiumAPI() && !$dontFallback) {
    38614370            return sodium_crypto_core_ristretto255_scalar_reduce($s);
    … …  
    39114420     * @throws SodiumException
    39124421     */
    3913     public static function sub(&$val, $addv)
    3914     {
     4422    public static function sub(
     4423        #[\SensitiveParameter]
     4424        &$val,
     4425        #[\SensitiveParameter]
     4426        $addv
     4427    ) {
    39154428        $val_len = ParagonIE_Sodium_Core_Util::strlen($val);
    39164429        $addv_len = ParagonIE_Sodium_Core_Util::strlen($addv);

  • trunk/src/wp-includes/sodium_compat/src/Core/Curve25519/Ge/Cached.php

    r46586 r58752  
    4141     */
    4242    public function __construct(
    43         ParagonIE_Sodium_Core_Curve25519_Fe $YplusX = null,
    44         ParagonIE_Sodium_Core_Curve25519_Fe $YminusX = null,
    45         ParagonIE_Sodium_Core_Curve25519_Fe $Z = null,
    46         ParagonIE_Sodium_Core_Curve25519_Fe $T2d = null
     43        $YplusX = null,
     44        $YminusX = null,
     45        $Z = null,
     46        $T2d = null
    4747    ) {
    4848        if ($YplusX === null) {
    4949            $YplusX = new ParagonIE_Sodium_Core_Curve25519_Fe();
     50        }
     51        if (!($YplusX instanceof ParagonIE_Sodium_Core_Curve25519_Fe)) {
     52            throw new TypeError('Argument 1 must be an instance of ParagonIE_Sodium_Core_Curve25519_Fe');
    5053        }
    5154        $this->YplusX = $YplusX;
    … …  
    5356            $YminusX = new ParagonIE_Sodium_Core_Curve25519_Fe();
    5457        }
     58        if (!($YminusX instanceof ParagonIE_Sodium_Core_Curve25519_Fe)) {
     59            throw new TypeError('Argument 2 must be an instance of ParagonIE_Sodium_Core_Curve25519_Fe');
     60        }
    5561        $this->YminusX = $YminusX;
    5662        if ($Z === null) {
    5763            $Z = new ParagonIE_Sodium_Core_Curve25519_Fe();
     64        }
     65        if (!($Z instanceof ParagonIE_Sodium_Core_Curve25519_Fe)) {
     66            throw new TypeError('Argument 3 must be an instance of ParagonIE_Sodium_Core_Curve25519_Fe');
    5867        }
    5968        $this->Z = $Z;
    … …  
    6170            $T2d = new ParagonIE_Sodium_Core_Curve25519_Fe();
    6271        }
     72        if (!($T2d instanceof ParagonIE_Sodium_Core_Curve25519_Fe)) {
     73            throw new TypeError('Argument 4 must be an instance of ParagonIE_Sodium_Core_Curve25519_Fe');
     74        }
    6375        $this->T2d = $T2d;
    6476    }

  • trunk/src/wp-includes/sodium_compat/src/Core/Curve25519/Ge/P1p1.php

    r46586 r58752  
    4040     */
    4141    public function __construct(
    42         ParagonIE_Sodium_Core_Curve25519_Fe $x = null,
    43         ParagonIE_Sodium_Core_Curve25519_Fe $y = null,
    44         ParagonIE_Sodium_Core_Curve25519_Fe $z = null,
    45         ParagonIE_Sodium_Core_Curve25519_Fe $t = null
     42        $x = null,
     43        $y = null,
     44        $z = null,
     45        $t = null
    4646    ) {
    4747        if ($x === null) {
    4848            $x = new ParagonIE_Sodium_Core_Curve25519_Fe();
     49        }
     50        if (!($x instanceof ParagonIE_Sodium_Core_Curve25519_Fe)) {
     51            throw new TypeError('Argument 1 must be an instance of ParagonIE_Sodium_Core_Curve25519_Fe');
    4952        }
    5053        $this->X = $x;
    … …  
    5255            $y = new ParagonIE_Sodium_Core_Curve25519_Fe();
    5356        }
     57        if (!($y instanceof ParagonIE_Sodium_Core_Curve25519_Fe)) {
     58            throw new TypeError('Argument 2 must be an instance of ParagonIE_Sodium_Core_Curve25519_Fe');
     59        }
    5460        $this->Y = $y;
    5561        if ($z === null) {
    5662            $z = new ParagonIE_Sodium_Core_Curve25519_Fe();
     63        }
     64        if (!($z instanceof ParagonIE_Sodium_Core_Curve25519_Fe)) {
     65            throw new TypeError('Argument 3 must be an instance of ParagonIE_Sodium_Core_Curve25519_Fe');
    5766        }
    5867        $this->Z = $z;
    … …  
    6069            $t = new ParagonIE_Sodium_Core_Curve25519_Fe();
    6170        }
     71        if (!($t instanceof ParagonIE_Sodium_Core_Curve25519_Fe)) {
     72            throw new TypeError('Argument 4 must be an instance of ParagonIE_Sodium_Core_Curve25519_Fe');
     73        }
    6274        $this->T = $t;
    6375    }

  • trunk/src/wp-includes/sodium_compat/src/Core/Curve25519/Ge/P2.php

    r46586 r58752  
    3535     */
    3636    public function __construct(
    37         ParagonIE_Sodium_Core_Curve25519_Fe $x = null,
    38         ParagonIE_Sodium_Core_Curve25519_Fe $y = null,
    39         ParagonIE_Sodium_Core_Curve25519_Fe $z = null
     37        $x = null,
     38        $y = null,
     39        $z = null
    4040    ) {
    4141        if ($x === null) {
    4242            $x = new ParagonIE_Sodium_Core_Curve25519_Fe();
     43        }
     44        if (!($x instanceof ParagonIE_Sodium_Core_Curve25519_Fe)) {
     45            throw new TypeError('Argument 1 must be an instance of ParagonIE_Sodium_Core_Curve25519_Fe');
    4346        }
    4447        $this->X = $x;
    … …  
    4649            $y = new ParagonIE_Sodium_Core_Curve25519_Fe();
    4750        }
     51        if (!($y instanceof ParagonIE_Sodium_Core_Curve25519_Fe)) {
     52            throw new TypeError('Argument 2 must be an instance of ParagonIE_Sodium_Core_Curve25519_Fe');
     53        }
    4854        $this->Y = $y;
    4955        if ($z === null) {
    5056            $z = new ParagonIE_Sodium_Core_Curve25519_Fe();
    5157        }
     58        if (!($z instanceof ParagonIE_Sodium_Core_Curve25519_Fe)) {
     59            throw new TypeError('Argument 3 must be an instance of ParagonIE_Sodium_Core_Curve25519_Fe');
     60        }
    5261        $this->Z = $z;
    5362    }

  • trunk/src/wp-includes/sodium_compat/src/Core/Curve25519/Ge/P3.php

    r46586 r58752  
    4141     */
    4242    public function __construct(
    43         ParagonIE_Sodium_Core_Curve25519_Fe $x = null,
    44         ParagonIE_Sodium_Core_Curve25519_Fe $y = null,
    45         ParagonIE_Sodium_Core_Curve25519_Fe $z = null,
    46         ParagonIE_Sodium_Core_Curve25519_Fe $t = null
     43        $x = null,
     44        $y = null,
     45        $z = null,
     46        $t = null
    4747    ) {
    4848        if ($x === null) {
    4949            $x = new ParagonIE_Sodium_Core_Curve25519_Fe();
     50        }
     51        if (!($x instanceof ParagonIE_Sodium_Core_Curve25519_Fe)) {
     52            throw new TypeError('Argument 1 must be an instance of ParagonIE_Sodium_Core_Curve25519_Fe');
    5053        }
    5154        $this->X = $x;
    … …  
    5356            $y = new ParagonIE_Sodium_Core_Curve25519_Fe();
    5457        }
     58        if (!($y instanceof ParagonIE_Sodium_Core_Curve25519_Fe)) {
     59            throw new TypeError('Argument 2 must be an instance of ParagonIE_Sodium_Core_Curve25519_Fe');
     60        }
    5561        $this->Y = $y;
    5662        if ($z === null) {
    5763            $z = new ParagonIE_Sodium_Core_Curve25519_Fe();
     64        }
     65        if (!($z instanceof ParagonIE_Sodium_Core_Curve25519_Fe)) {
     66            throw new TypeError('Argument 3 must be an instance of ParagonIE_Sodium_Core_Curve25519_Fe');
    5867        }
    5968        $this->Z = $z;
    … …  
    6170            $t = new ParagonIE_Sodium_Core_Curve25519_Fe();
    6271        }
     72        if (!($t instanceof ParagonIE_Sodium_Core_Curve25519_Fe)) {
     73            throw new TypeError('Argument 4 must be an instance of ParagonIE_Sodium_Core_Curve25519_Fe');
     74        }
    6375        $this->T = $t;
    6476    }

  • trunk/src/wp-includes/sodium_compat/src/Core/Curve25519/Ge/Precomp.php

    r46586 r58752  
    3535     */
    3636    public function __construct(
    37         ParagonIE_Sodium_Core_Curve25519_Fe $yplusx = null,
    38         ParagonIE_Sodium_Core_Curve25519_Fe $yminusx = null,
    39         ParagonIE_Sodium_Core_Curve25519_Fe $xy2d = null
     37        $yplusx = null,
     38        $yminusx = null,
     39        $xy2d = null
    4040    ) {
    4141        if ($yplusx === null) {
    4242            $yplusx = new ParagonIE_Sodium_Core_Curve25519_Fe();
     43        }
     44        if (!($yplusx instanceof ParagonIE_Sodium_Core_Curve25519_Fe)) {
     45            throw new TypeError('Argument 1 must be an instance of ParagonIE_Sodium_Core_Curve25519_Fe');
    4346        }
    4447        $this->yplusx = $yplusx;
    … …  
    4649            $yminusx = new ParagonIE_Sodium_Core_Curve25519_Fe();
    4750        }
     51        if (!($yminusx instanceof ParagonIE_Sodium_Core_Curve25519_Fe)) {
     52            throw new TypeError('Argument 2 must be an instance of ParagonIE_Sodium_Core_Curve25519_Fe');
     53        }
    4854        $this->yminusx = $yminusx;
    4955        if ($xy2d === null) {
    5056            $xy2d = new ParagonIE_Sodium_Core_Curve25519_Fe();
    5157        }
     58        if (!($xy2d instanceof ParagonIE_Sodium_Core_Curve25519_Fe)) {
     59            throw new TypeError('Argument 3 must be an instance of ParagonIE_Sodium_Core_Curve25519_Fe');
     60        }
    5261        $this->xy2d = $xy2d;
    5362    }

  • trunk/src/wp-includes/sodium_compat/src/Core/Util.php

    r54310 r58752  
    1010abstract class ParagonIE_Sodium_Core_Util
    1111{
     12    const U32_MAX = 0xFFFFFFFF;
     13
    1214    /**
    1315     * @param int $integer
    … …  
    3234            (($negative >> $realSize) & 1)
    3335        );
     36    }
     37
     38    /**
     39     * @param string $a
     40     * @param string $b
     41     * @return string
     42     * @throws SodiumException
     43     */
     44    public static function andStrings($a, $b)
     45    {
     46        /* Type checks: */
     47        if (!is_string($a)) {
     48            throw new TypeError('Argument 1 must be a string');
     49        }
     50        if (!is_string($b)) {
     51            throw new TypeError('Argument 2 must be a string');
     52        }
     53        $len = self::strlen($a);
     54        if (self::strlen($b) !== $len) {
     55            throw new SodiumException('Both strings must be of equal length to combine with bitwise AND');
     56        }
     57        return $a & $b;
    3458    }
    3559

  • trunk/src/wp-includes/sodium_compat/src/File.php

    r52988 r58752  
    2626     * @throws TypeError
    2727     */
    28     public static function box($inputFile, $outputFile, $nonce, $keyPair)
    29     {
     28    public static function box(
     29        $inputFile,
     30        $outputFile,
     31        $nonce,
     32        #[\SensitiveParameter]
     33        $keyPair
     34    ) {
    3035        /* Type checks: */
    3136        if (!is_string($inputFile)) {
    … …  
    9297     * @throws TypeError
    9398     */
    94     public static function box_open($inputFile, $outputFile, $nonce, $keypair)
    95     {
     99    public static function box_open(
     100        $inputFile,
     101        $outputFile,
     102        $nonce,
     103        #[\SensitiveParameter]
     104        $keypair
     105    ) {
    96106        /* Type checks: */
    97107        if (!is_string($inputFile)) {
    … …  
    162172     * @throws TypeError
    163173     */
    164     public static function box_seal($inputFile, $outputFile, $publicKey)
    165     {
     174    public static function box_seal(
     175        $inputFile,
     176        $outputFile,
     177        #[\SensitiveParameter]
     178        $publicKey
     179    ) {
    166180        /* Type checks: */
    167181        if (!is_string($inputFile)) {
    … …  
    266280     * @throws TypeError
    267281     */
    268     public static function box_seal_open($inputFile, $outputFile, $ecdhKeypair)
    269     {
     282    public static function box_seal_open(
     283        $inputFile,
     284        $outputFile,
     285        #[\SensitiveParameter]
     286        $ecdhKeypair
     287    ) {
    270288        /* Type checks: */
    271289        if (!is_string($inputFile)) {
    … …  
    351369     * @psalm-suppress FailedTypeResolution
    352370     */
    353     public static function generichash($filePath, $key = '', $outputLength = 32)
    354     {
     371    public static function generichash(
     372        $filePath,
     373        #[\SensitiveParameter]
     374        $key = '',
     375        $outputLength = 32
     376    ) {
    355377        /* Type checks: */
    356378        if (!is_string($filePath)) {
    … …  
    429451     * @throws TypeError
    430452     */
    431     public static function secretbox($inputFile, $outputFile, $nonce, $key)
    432     {
     453    public static function secretbox(
     454        $inputFile,
     455        $outputFile,
     456        $nonce,
     457        #[\SensitiveParameter]
     458        $key
     459    ) {
    433460        /* Type checks: */
    434461        if (!is_string($inputFile)) {
    … …  
    494521     * @throws TypeError
    495522     */
    496     public static function secretbox_open($inputFile, $outputFile, $nonce, $key)
    497     {
     523    public static function secretbox_open(
     524        $inputFile,
     525        $outputFile,
     526        $nonce,
     527        #[\SensitiveParameter]
     528        $key
     529    ) {
    498530        /* Type checks: */
    499531        if (!is_string($inputFile)) {
    … …  
    561593     * @throws TypeError
    562594     */
    563     public static function sign($filePath, $secretKey)
    564     {
     595    public static function sign(
     596        $filePath,
     597        #[\SensitiveParameter]
     598        $secretKey
     599    ) {
    565600        /* Type checks: */
    566601        if (!is_string($filePath)) {
    … …  
    657692     * @throws Exception
    658693     */
    659     public static function verify($sig, $filePath, $publicKey)
    660     {
     694    public static function verify(
     695        $sig,
     696        $filePath,
     697        $publicKey
     698    ) {
    661699        /* Type checks: */
    662700        if (!is_string($sig)) {
Note: See TracChangeset for help on using the changeset viewer.