diff options
Diffstat (limited to 'srcs/wordpress/wp-includes/sodium_compat/lib')
5 files changed, 2370 insertions, 0 deletions
diff --git a/srcs/wordpress/wp-includes/sodium_compat/lib/constants.php b/srcs/wordpress/wp-includes/sodium_compat/lib/constants.php new file mode 100644 index 0000000..b6a120e --- /dev/null +++ b/srcs/wordpress/wp-includes/sodium_compat/lib/constants.php @@ -0,0 +1,52 @@ +<?php +namespace Sodium; + +require_once dirname(dirname(__FILE__)) . '/autoload.php'; + +use ParagonIE_Sodium_Compat; + +const CRYPTO_AEAD_AES256GCM_KEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_AEAD_AES256GCM_KEYBYTES; +const CRYPTO_AEAD_AES256GCM_NSECBYTES = ParagonIE_Sodium_Compat::CRYPTO_AEAD_AES256GCM_NSECBYTES; +const CRYPTO_AEAD_AES256GCM_NPUBBYTES = ParagonIE_Sodium_Compat::CRYPTO_AEAD_AES256GCM_NPUBBYTES; +const CRYPTO_AEAD_AES256GCM_ABYTES = ParagonIE_Sodium_Compat::CRYPTO_AEAD_AES256GCM_ABYTES; +const CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES; +const CRYPTO_AEAD_CHACHA20POLY1305_NSECBYTES = ParagonIE_Sodium_Compat::CRYPTO_AEAD_CHACHA20POLY1305_NSECBYTES; +const CRYPTO_AEAD_CHACHA20POLY1305_NPUBBYTES = ParagonIE_Sodium_Compat::CRYPTO_AEAD_CHACHA20POLY1305_NPUBBYTES; +const CRYPTO_AEAD_CHACHA20POLY1305_ABYTES = ParagonIE_Sodium_Compat::CRYPTO_AEAD_CHACHA20POLY1305_ABYTES; +const CRYPTO_AEAD_CHACHA20POLY1305_IETF_KEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_AEAD_CHACHA20POLY1305_IETF_KEYBYTES; +const CRYPTO_AEAD_CHACHA20POLY1305_IETF_NSECBYTES = ParagonIE_Sodium_Compat::CRYPTO_AEAD_CHACHA20POLY1305_IETF_NSECBYTES; +const CRYPTO_AEAD_CHACHA20POLY1305_IETF_NPUBBYTES = ParagonIE_Sodium_Compat::CRYPTO_AEAD_CHACHA20POLY1305_IETF_NPUBBYTES; +const CRYPTO_AEAD_CHACHA20POLY1305_IETF_ABYTES = ParagonIE_Sodium_Compat::CRYPTO_AEAD_CHACHA20POLY1305_IETF_ABYTES; +const CRYPTO_AUTH_BYTES = ParagonIE_Sodium_Compat::CRYPTO_AUTH_BYTES; +const CRYPTO_AUTH_KEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_AUTH_KEYBYTES; +const CRYPTO_BOX_SEALBYTES = ParagonIE_Sodium_Compat::CRYPTO_BOX_SEALBYTES; +const CRYPTO_BOX_SECRETKEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_BOX_SECRETKEYBYTES; +const CRYPTO_BOX_PUBLICKEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_BOX_PUBLICKEYBYTES; +const CRYPTO_BOX_KEYPAIRBYTES = ParagonIE_Sodium_Compat::CRYPTO_BOX_KEYPAIRBYTES; +const CRYPTO_BOX_MACBYTES = ParagonIE_Sodium_Compat::CRYPTO_BOX_MACBYTES; +const CRYPTO_BOX_NONCEBYTES = ParagonIE_Sodium_Compat::CRYPTO_BOX_NONCEBYTES; +const CRYPTO_BOX_SEEDBYTES = ParagonIE_Sodium_Compat::CRYPTO_BOX_SEEDBYTES; +const CRYPTO_KX_BYTES = ParagonIE_Sodium_Compat::CRYPTO_KX_BYTES; +const CRYPTO_KX_SEEDBYTES = ParagonIE_Sodium_Compat::CRYPTO_KX_SEEDBYTES; +const CRYPTO_KX_PUBLICKEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_KX_PUBLICKEYBYTES; +const CRYPTO_KX_SECRETKEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_KX_SECRETKEYBYTES; +const CRYPTO_GENERICHASH_BYTES = ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_BYTES; +const CRYPTO_GENERICHASH_BYTES_MIN = ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_BYTES_MIN; +const CRYPTO_GENERICHASH_BYTES_MAX = ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_BYTES_MAX; +const CRYPTO_GENERICHASH_KEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_KEYBYTES; +const CRYPTO_GENERICHASH_KEYBYTES_MIN = ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_KEYBYTES_MIN; +const CRYPTO_GENERICHASH_KEYBYTES_MAX = ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_KEYBYTES_MAX; +const CRYPTO_SCALARMULT_BYTES = ParagonIE_Sodium_Compat::CRYPTO_SCALARMULT_BYTES; +const CRYPTO_SCALARMULT_SCALARBYTES = ParagonIE_Sodium_Compat::CRYPTO_SCALARMULT_SCALARBYTES; +const CRYPTO_SHORTHASH_BYTES = ParagonIE_Sodium_Compat::CRYPTO_SHORTHASH_BYTES; +const CRYPTO_SHORTHASH_KEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_SHORTHASH_KEYBYTES; +const CRYPTO_SECRETBOX_KEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_KEYBYTES; +const CRYPTO_SECRETBOX_MACBYTES = ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_MACBYTES; +const CRYPTO_SECRETBOX_NONCEBYTES = ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_NONCEBYTES; +const CRYPTO_SIGN_BYTES = ParagonIE_Sodium_Compat::CRYPTO_SIGN_BYTES; +const CRYPTO_SIGN_SEEDBYTES = ParagonIE_Sodium_Compat::CRYPTO_SIGN_SEEDBYTES; +const CRYPTO_SIGN_PUBLICKEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_SIGN_PUBLICKEYBYTES; +const CRYPTO_SIGN_SECRETKEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_SIGN_SECRETKEYBYTES; +const CRYPTO_SIGN_KEYPAIRBYTES = ParagonIE_Sodium_Compat::CRYPTO_SIGN_KEYPAIRBYTES; +const CRYPTO_STREAM_KEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_STREAM_KEYBYTES; +const CRYPTO_STREAM_NONCEBYTES = ParagonIE_Sodium_Compat::CRYPTO_STREAM_NONCEBYTES; diff --git a/srcs/wordpress/wp-includes/sodium_compat/lib/namespaced.php b/srcs/wordpress/wp-includes/sodium_compat/lib/namespaced.php new file mode 100644 index 0000000..77551fd --- /dev/null +++ b/srcs/wordpress/wp-includes/sodium_compat/lib/namespaced.php @@ -0,0 +1,48 @@ +<?php + +require_once dirname(dirname(__FILE__)) . '/autoload.php'; + +if (PHP_VERSION_ID < 50300) { + return; +} + +/* + * This file is just for convenience, to allow developers to reduce verbosity when + * they add this project to their libraries. + * + * Replace this: + * + * $x = ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_encrypt(...$args); + * + * with this: + * + * use ParagonIE\Sodium\Compat; + * + * $x = Compat::crypto_aead_xchacha20poly1305_encrypt(...$args); + */ +spl_autoload_register(function ($class) { + if ($class[0] === '\\') { + $class = substr($class, 1); + } + $namespace = 'ParagonIE\\Sodium'; + // Does the class use the namespace prefix? + $len = strlen($namespace); + if (strncmp($namespace, $class, $len) !== 0) { + // no, move to the next registered autoloader + return false; + } + + // Get the relative class name + $relative_class = substr($class, $len); + + // Replace the namespace prefix with the base directory, replace namespace + // separators with directory separators in the relative class name, append + // with .php + $file = dirname(dirname(__FILE__)) . '/namespaced/' . str_replace('\\', '/', $relative_class) . '.php'; + // if the file exists, require it + if (file_exists($file)) { + require_once $file; + return true; + } + return false; +}); diff --git a/srcs/wordpress/wp-includes/sodium_compat/lib/php72compat.php b/srcs/wordpress/wp-includes/sodium_compat/lib/php72compat.php new file mode 100644 index 0000000..c39ec26 --- /dev/null +++ b/srcs/wordpress/wp-includes/sodium_compat/lib/php72compat.php @@ -0,0 +1,1354 @@ +<?php + +require_once dirname(dirname(__FILE__)) . '/autoload.php'; + +/** + * This file will monkey patch the pure-PHP implementation in place of the + * PECL functions and constants, but only if they do not already exist. + * + * Thus, the functions or constants just proxy to the appropriate + * ParagonIE_Sodium_Compat method or class constant, respectively. + */ +foreach (array( + 'BASE64_VARIANT_ORIGINAL', + 'BASE64_VARIANT_ORIGINAL_NO_PADDING', + 'BASE64_VARIANT_URLSAFE', + 'BASE64_VARIANT_URLSAFE_NO_PADDING', + 'CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES', + 'CRYPTO_AEAD_CHACHA20POLY1305_NSECBYTES', + 'CRYPTO_AEAD_CHACHA20POLY1305_NPUBBYTES', + 'CRYPTO_AEAD_CHACHA20POLY1305_ABYTES', + 'CRYPTO_AEAD_AES256GCM_KEYBYTES', + 'CRYPTO_AEAD_AES256GCM_NSECBYTES', + 'CRYPTO_AEAD_AES256GCM_NPUBBYTES', + 'CRYPTO_AEAD_AES256GCM_ABYTES', + 'CRYPTO_AEAD_CHACHA20POLY1305_IETF_KEYBYTES', + 'CRYPTO_AEAD_CHACHA20POLY1305_IETF_NSECBYTES', + 'CRYPTO_AEAD_CHACHA20POLY1305_IETF_NPUBBYTES', + 'CRYPTO_AEAD_CHACHA20POLY1305_IETF_ABYTES', + 'CRYPTO_AUTH_BYTES', + 'CRYPTO_AUTH_KEYBYTES', + 'CRYPTO_BOX_SEALBYTES', + 'CRYPTO_BOX_SECRETKEYBYTES', + 'CRYPTO_BOX_PUBLICKEYBYTES', + 'CRYPTO_BOX_KEYPAIRBYTES', + 'CRYPTO_BOX_MACBYTES', + 'CRYPTO_BOX_NONCEBYTES', + 'CRYPTO_BOX_SEEDBYTES', + 'CRYPTO_KDF_BYTES_MIN', + 'CRYPTO_KDF_BYTES_MAX', + 'CRYPTO_KDF_CONTEXTBYTES', + 'CRYPTO_KDF_KEYBYTES', + 'CRYPTO_KX_BYTES', + 'CRYPTO_KX_KEYPAIRBYTES', + 'CRYPTO_KX_PRIMITIVE', + 'CRYPTO_KX_SEEDBYTES', + 'CRYPTO_KX_PUBLICKEYBYTES', + 'CRYPTO_KX_SECRETKEYBYTES', + 'CRYPTO_KX_SESSIONKEYBYTES', + 'CRYPTO_GENERICHASH_BYTES', + 'CRYPTO_GENERICHASH_BYTES_MIN', + 'CRYPTO_GENERICHASH_BYTES_MAX', + 'CRYPTO_GENERICHASH_KEYBYTES', + 'CRYPTO_GENERICHASH_KEYBYTES_MIN', + 'CRYPTO_GENERICHASH_KEYBYTES_MAX', + 'CRYPTO_PWHASH_SALTBYTES', + 'CRYPTO_PWHASH_STRPREFIX', + 'CRYPTO_PWHASH_ALG_ARGON2I13', + 'CRYPTO_PWHASH_ALG_ARGON2ID13', + 'CRYPTO_PWHASH_MEMLIMIT_INTERACTIVE', + 'CRYPTO_PWHASH_OPSLIMIT_INTERACTIVE', + 'CRYPTO_PWHASH_MEMLIMIT_MODERATE', + 'CRYPTO_PWHASH_OPSLIMIT_MODERATE', + 'CRYPTO_PWHASH_MEMLIMIT_SENSITIVE', + 'CRYPTO_PWHASH_OPSLIMIT_SENSITIVE', + 'CRYPTO_SCALARMULT_BYTES', + 'CRYPTO_SCALARMULT_SCALARBYTES', + 'CRYPTO_SHORTHASH_BYTES', + 'CRYPTO_SHORTHASH_KEYBYTES', + 'CRYPTO_SECRETBOX_KEYBYTES', + 'CRYPTO_SECRETBOX_MACBYTES', + 'CRYPTO_SECRETBOX_NONCEBYTES', + 'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_ABYTES', + 'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_HEADERBYTES', + 'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_KEYBYTES', + 'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_PUSH', + 'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_PULL', + 'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_REKEY', + 'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_FINAL', + 'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_MESSAGEBYTES_MAX', + 'CRYPTO_SIGN_BYTES', + 'CRYPTO_SIGN_SEEDBYTES', + 'CRYPTO_SIGN_PUBLICKEYBYTES', + 'CRYPTO_SIGN_SECRETKEYBYTES', + 'CRYPTO_SIGN_KEYPAIRBYTES', + 'CRYPTO_STREAM_KEYBYTES', + 'CRYPTO_STREAM_NONCEBYTES', + 'LIBRARY_VERSION_MAJOR', + 'LIBRARY_VERSION_MINOR', + 'VERSION_STRING' + ) as $constant +) { + if (!defined("SODIUM_$constant") && defined("ParagonIE_Sodium_Compat::$constant")) { + define("SODIUM_$constant", constant("ParagonIE_Sodium_Compat::$constant")); + } +} +if (!is_callable('sodium_add')) { + /** + * @see ParagonIE_Sodium_Compat::add() + * @param string $val + * @param string $addv + * @return void + * @throws SodiumException + */ + function sodium_add(&$val, $addv) + { + ParagonIE_Sodium_Compat::add($val, $addv); + } +} +if (!is_callable('sodium_base642bin')) { + /** + * @see ParagonIE_Sodium_Compat::bin2base64() + * @param string $string + * @param int $variant + * @param string $ignore + * @return string + * @throws SodiumException + * @throws TypeError + */ + function sodium_base642bin($string, $variant, $ignore ='') + { + return ParagonIE_Sodium_Compat::base642bin($string, $variant, $ignore); + } +} +if (!is_callable('sodium_bin2base64')) { + /** + * @see ParagonIE_Sodium_Compat::bin2base64() + * @param string $string + * @param int $variant + * @return string + * @throws SodiumException + * @throws TypeError + */ + function sodium_bin2base64($string, $variant) + { + return ParagonIE_Sodium_Compat::bin2base64($string, $variant); + } +} +if (!is_callable('sodium_bin2hex')) { + /** + * @see ParagonIE_Sodium_Compat::hex2bin() + * @param string $string + * @return string + * @throws SodiumException + * @throws TypeError + */ + function sodium_bin2hex($string) + { + return ParagonIE_Sodium_Compat::bin2hex($string); + } +} +if (!is_callable('sodium_compare')) { + /** + * @see ParagonIE_Sodium_Compat::compare() + * @param string $a + * @param string $b + * @return int + * @throws SodiumException + * @throws TypeError + */ + function sodium_compare($a, $b) + { + return ParagonIE_Sodium_Compat::compare($a, $b); + } +} +if (!is_callable('sodium_crypto_aead_aes256gcm_decrypt')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt() + * @param string $message + * @param string $assocData + * @param string $nonce + * @param string $key + * @return string|bool + */ + function sodium_crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key) + { + try { + return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key); + } catch (Error $ex) { + return false; + } catch (Exception $ex) { + return false; + } + } +} +if (!is_callable('sodium_crypto_aead_aes256gcm_encrypt')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt() + * @param string $message + * @param string $assocData + * @param string $nonce + * @param string $key + * @return string + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_aead_aes256gcm_encrypt($message, $assocData, $nonce, $key) + { + return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt($message, $assocData, $nonce, $key); + } +} +if (!is_callable('sodium_crypto_aead_aes256gcm_is_available')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_is_available() + * @return bool + */ + function sodium_crypto_aead_aes256gcm_is_available() + { + return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_is_available(); + } +} +if (!is_callable('sodium_crypto_aead_chacha20poly1305_decrypt')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt() + * @param string $message + * @param string $assocData + * @param string $nonce + * @param string $key + * @return string|bool + */ + function sodium_crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key) + { + try { + return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key); + } catch (Error $ex) { + return false; + } catch (Exception $ex) { + return false; + } + } +} +if (!is_callable('sodium_crypto_aead_chacha20poly1305_encrypt')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt() + * @param string $message + * @param string $assocData + * @param string $nonce + * @param string $key + * @return string + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_aead_chacha20poly1305_encrypt($message, $assocData, $nonce, $key) + { + return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt($message, $assocData, $nonce, $key); + } +} +if (!is_callable('sodium_crypto_aead_chacha20poly1305_keygen')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_keygen() + * @return string + * @throws Exception + */ + function sodium_crypto_aead_chacha20poly1305_keygen() + { + return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_keygen(); + } +} +if (!is_callable('sodium_crypto_aead_chacha20poly1305_ietf_decrypt')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt() + * @param string $message + * @param string $assocData + * @param string $nonce + * @param string $key + * @return string|bool + */ + function sodium_crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key) + { + try { + return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key); + } catch (Error $ex) { + return false; + } catch (Exception $ex) { + return false; + } + } +} +if (!is_callable('sodium_crypto_aead_chacha20poly1305_ietf_encrypt')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt() + * @param string $message + * @param string $assocData + * @param string $nonce + * @param string $key + * @return string + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_aead_chacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key) + { + return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key); + } +} +if (!is_callable('sodium_crypto_aead_chacha20poly1305_ietf_keygen')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_keygen() + * @return string + * @throws Exception + */ + function sodium_crypto_aead_chacha20poly1305_ietf_keygen() + { + return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_keygen(); + } +} +if (!is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_decrypt')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_decrypt() + * @param string $message + * @param string $assocData + * @param string $nonce + * @param string $key + * @return string|bool + */ + function sodium_crypto_aead_xchacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key) + { + try { + return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key, true); + } catch (Error $ex) { + return false; + } catch (Exception $ex) { + return false; + } + } +} +if (!is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_encrypt')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_encrypt() + * @param string $message + * @param string $assocData + * @param string $nonce + * @param string $key + * @return string + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_aead_xchacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key) + { + return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key, true); + } +} +if (!is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_keygen')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_keygen() + * @return string + * @throws Exception + */ + function sodium_crypto_aead_xchacha20poly1305_ietf_keygen() + { + return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_keygen(); + } +} +if (!is_callable('sodium_crypto_auth')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_auth() + * @param string $message + * @param string $key + * @return string + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_auth($message, $key) + { + return ParagonIE_Sodium_Compat::crypto_auth($message, $key); + } +} +if (!is_callable('sodium_crypto_auth_keygen')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_auth_keygen() + * @return string + * @throws Exception + */ + function sodium_crypto_auth_keygen() + { + return ParagonIE_Sodium_Compat::crypto_auth_keygen(); + } +} +if (!is_callable('sodium_crypto_auth_verify')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_auth_verify() + * @param string $mac + * @param string $message + * @param string $key + * @return bool + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_auth_verify($mac, $message, $key) + { + return ParagonIE_Sodium_Compat::crypto_auth_verify($mac, $message, $key); + } +} +if (!is_callable('sodium_crypto_box')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_box() + * @param string $message + * @param string $nonce + * @param string $kp + * @return string + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_box($message, $nonce, $kp) + { + return ParagonIE_Sodium_Compat::crypto_box($message, $nonce, $kp); + } +} +if (!is_callable('sodium_crypto_box_keypair')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_box_keypair() + * @return string + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_box_keypair() + { + return ParagonIE_Sodium_Compat::crypto_box_keypair(); + } +} +if (!is_callable('sodium_crypto_box_keypair_from_secretkey_and_publickey')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey() + * @param string $sk + * @param string $pk + * @return string + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_box_keypair_from_secretkey_and_publickey($sk, $pk) + { + return ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey($sk, $pk); + } +} +if (!is_callable('sodium_crypto_box_open')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_box_open() + * @param string $message + * @param string $nonce + * @param string $kp + * @return string|bool + */ + function sodium_crypto_box_open($message, $nonce, $kp) + { + try { + return ParagonIE_Sodium_Compat::crypto_box_open($message, $nonce, $kp); + } catch (Error $ex) { + return false; + } catch (Exception $ex) { + return false; + } + } +} +if (!is_callable('sodium_crypto_box_publickey')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_box_publickey() + * @param string $keypair + * @return string + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_box_publickey($keypair) + { + return ParagonIE_Sodium_Compat::crypto_box_publickey($keypair); + } +} +if (!is_callable('sodium_crypto_box_publickey_from_secretkey')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey() + * @param string $sk + * @return string + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_box_publickey_from_secretkey($sk) + { + return ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey($sk); + } +} +if (!is_callable('sodium_crypto_box_seal')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_box_seal() + * @param string $message + * @param string $publicKey + * @return string + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_box_seal($message, $publicKey) + { + return ParagonIE_Sodium_Compat::crypto_box_seal($message, $publicKey); + } +} +if (!is_callable('sodium_crypto_box_seal_open')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_box_seal_open() + * @param string $message + * @param string $kp + * @return string|bool + * @throws SodiumException + */ + function sodium_crypto_box_seal_open($message, $kp) + { + try { + return ParagonIE_Sodium_Compat::crypto_box_seal_open($message, $kp); + } catch (SodiumException $ex) { + if ($ex->getMessage() === 'Argument 2 must be CRYPTO_BOX_KEYPAIRBYTES long.') { + throw $ex; + } + return false; + } + } +} +if (!is_callable('sodium_crypto_box_secretkey')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_box_secretkey() + * @param string $keypair + * @return string + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_box_secretkey($keypair) + { + return ParagonIE_Sodium_Compat::crypto_box_secretkey($keypair); + } +} +if (!is_callable('sodium_crypto_box_seed_keypair')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_box_seed_keypair() + * @param string $seed + * @return string + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_box_seed_keypair($seed) + { + return ParagonIE_Sodium_Compat::crypto_box_seed_keypair($seed); + } +} +if (!is_callable('sodium_crypto_generichash')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_generichash() + * @param string $message + * @param string|null $key + * @param int $outLen + * @return string + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_generichash($message, $key = null, $outLen = 32) + { + return ParagonIE_Sodium_Compat::crypto_generichash($message, $key, $outLen); + } +} +if (!is_callable('sodium_crypto_generichash_final')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_generichash_final() + * @param string|null $ctx + * @param int $outputLength + * @return string + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_generichash_final(&$ctx, $outputLength = 32) + { + return ParagonIE_Sodium_Compat::crypto_generichash_final($ctx, $outputLength); + } +} +if (!is_callable('sodium_crypto_generichash_init')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_generichash_init() + * @param string|null $key + * @param int $outLen + * @return string + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_generichash_init($key = null, $outLen = 32) + { + return ParagonIE_Sodium_Compat::crypto_generichash_init($key, $outLen); + } +} +if (!is_callable('sodium_crypto_generichash_keygen')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_generichash_keygen() + * @return string + * @throws Exception + */ + function sodium_crypto_generichash_keygen() + { + return ParagonIE_Sodium_Compat::crypto_generichash_keygen(); + } +} +if (!is_callable('sodium_crypto_generichash_update')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_generichash_update() + * @param string|null $ctx + * @param string $message + * @return void + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_generichash_update(&$ctx, $message = '') + { + ParagonIE_Sodium_Compat::crypto_generichash_update($ctx, $message); + } +} +if (!is_callable('sodium_crypto_kdf_keygen')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_kdf_keygen() + * @return string + * @throws Exception + */ + function sodium_crypto_kdf_keygen() + { + return ParagonIE_Sodium_Compat::crypto_kdf_keygen(); + } +} +if (!is_callable('sodium_crypto_kdf_derive_from_key')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_kdf_derive_from_key() + * @param int $subkey_len + * @param int $subkey_id + * @param string $context + * @param string $key + * @return string + * @throws Exception + */ + function sodium_crypto_kdf_derive_from_key($subkey_len, $subkey_id, $context, $key) + { + return ParagonIE_Sodium_Compat::crypto_kdf_derive_from_key( + $subkey_len, + $subkey_id, + $context, + $key + ); + } +} +if (!is_callable('sodium_crypto_kx')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_kx() + * @param string $my_secret + * @param string $their_public + * @param string $client_public + * @param string $server_public + * @return string + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_kx($my_secret, $their_public, $client_public, $server_public) + { + return ParagonIE_Sodium_Compat::crypto_kx( + $my_secret, + $their_public, + $client_public, + $server_public + ); + } +} +if (!is_callable('sodium_crypto_kx_seed_keypair')) { + /** + * @param string $seed + * @return string + * @throws Exception + */ + function sodium_crypto_kx_seed_keypair($seed) + { + return ParagonIE_Sodium_Compat::crypto_kx_seed_keypair($seed); + } +} +if (!is_callable('sodium_crypto_kx_keypair')) { + /** + * @return string + * @throws Exception + */ + function sodium_crypto_kx_keypair() + { + return ParagonIE_Sodium_Compat::crypto_kx_keypair(); + } +} +if (!is_callable('sodium_crypto_kx_client_session_keys')) { + /** + * @param string $keypair + * @param string $serverPublicKey + * @return array{0: string, 1: string} + * @throws SodiumException + */ + function sodium_crypto_kx_client_session_keys($keypair, $serverPublicKey) + { + return ParagonIE_Sodium_Compat::crypto_kx_client_session_keys($keypair, $serverPublicKey); + } +} +if (!is_callable('sodium_crypto_kx_server_session_keys')) { + /** + * @param string $keypair + * @param string $clientPublicKey + * @return array{0: string, 1: string} + * @throws SodiumException + */ + function sodium_crypto_kx_server_session_keys($keypair, $clientPublicKey) + { + return ParagonIE_Sodium_Compat::crypto_kx_server_session_keys($keypair, $clientPublicKey); + } +} +if (!is_callable('sodium_crypto_kx_secretkey')) { + /** + * @param string $keypair + * @return string + * @throws Exception + */ + function sodium_crypto_kx_secretkey($keypair) + { + return ParagonIE_Sodium_Compat::crypto_kx_secretkey($keypair); + } +} +if (!is_callable('sodium_crypto_kx_publickey')) { + /** + * @param string $keypair + * @return string + * @throws Exception + */ + function sodium_crypto_kx_publickey($keypair) + { + return ParagonIE_Sodium_Compat::crypto_kx_publickey($keypair); + } +} +if (!is_callable('sodium_crypto_pwhash')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_pwhash() + * @param int $outlen + * @param string $passwd + * @param string $salt + * @param int $opslimit + * @param int $memlimit + * @param int|null $algo + * @return string + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit, $algo = null) + { + return ParagonIE_Sodium_Compat::crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit, $algo); + } +} +if (!is_callable('sodium_crypto_pwhash_str')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_pwhash_str() + * @param string $passwd + * @param int $opslimit + * @param int $memlimit + * @return string + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_pwhash_str($passwd, $opslimit, $memlimit) + { + return ParagonIE_Sodium_Compat::crypto_pwhash_str($passwd, $opslimit, $memlimit); + } +} +if (!is_callable('sodium_crypto_pwhash_str_needs_rehash')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_pwhash_str_needs_rehash() + * @param string $hash + * @param int $opslimit + * @param int $memlimit + * @return bool + * + * @throws SodiumException + */ + function sodium_crypto_pwhash_str_needs_rehash($hash, $opslimit, $memlimit) + { + return ParagonIE_Sodium_Compat::crypto_pwhash_str_needs_rehash($hash, $opslimit, $memlimit); + } +} +if (!is_callable('sodium_crypto_pwhash_str_verify')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_pwhash_str_verify() + * @param string $passwd + * @param string $hash + * @return bool + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_pwhash_str_verify($passwd, $hash) + { + return ParagonIE_Sodium_Compat::crypto_pwhash_str_verify($passwd, $hash); + } +} +if (!is_callable('sodium_crypto_pwhash_scryptsalsa208sha256')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256() + * @param int $outlen + * @param string $passwd + * @param string $salt + * @param int $opslimit + * @param int $memlimit + * @return string + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_pwhash_scryptsalsa208sha256($outlen, $passwd, $salt, $opslimit, $memlimit) + { + return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256($outlen, $passwd, $salt, $opslimit, $memlimit); + } +} +if (!is_callable('sodium_crypto_pwhash_scryptsalsa208sha256_str')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str() + * @param string $passwd + * @param int $opslimit + * @param int $memlimit + * @return string + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit) + { + return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit); + } +} +if (!is_callable('sodium_crypto_pwhash_scryptsalsa208sha256_str_verify')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str_verify() + * @param string $passwd + * @param string $hash + * @return bool + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash) + { + return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash); + } +} +if (!is_callable('sodium_crypto_scalarmult')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_scalarmult() + * @param string $n + * @param string $p + * @return string + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_scalarmult($n, $p) + { + return ParagonIE_Sodium_Compat::crypto_scalarmult($n, $p); + } +} +if (!is_callable('sodium_crypto_scalarmult_base')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_scalarmult_base() + * @param string $n + * @return string + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_scalarmult_base($n) + { + return ParagonIE_Sodium_Compat::crypto_scalarmult_base($n); + } +} +if (!is_callable('sodium_crypto_secretbox')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_secretbox() + * @param string $message + * @param string $nonce + * @param string $key + * @return string + * @throws SodiumException + * @throws TypeError + */ + function sodium_crypto_secretbox($message, $nonce, $key) + { + return ParagonIE_Sodium_Compat::crypto_secretbox($message, $nonce, $key); + } +} +if (!is_callable('sodium_crypto_secretbox_keygen')) { + /** + * @see ParagonIE_Sodium_Compat::crypto_secretbox_keygen() + * @return string + * @throws Exception + */ + function sodium_crypto_secretbox_keygen() + { + return ParagonIE_Sodium_Compat::crypto_secretbox_keygen(); + |