[ Index ]

PHP Cross Reference of WordPress

title

Body

[close]

/wp-includes/sodium_compat/lib/ -> php72compat.php (source)

   1  <?php
   2  
   3  require_once dirname(dirname(__FILE__)) . '/autoload.php';
   4  
   5  /**
   6   * This file will monkey patch the pure-PHP implementation in place of the
   7   * PECL functions and constants, but only if they do not already exist.
   8   *
   9   * Thus, the functions or constants just proxy to the appropriate
  10   * ParagonIE_Sodium_Compat method or class constant, respectively.
  11   */
  12  foreach (array(
  13      'BASE64_VARIANT_ORIGINAL',
  14      'BASE64_VARIANT_ORIGINAL_NO_PADDING',
  15      'BASE64_VARIANT_URLSAFE',
  16      'BASE64_VARIANT_URLSAFE_NO_PADDING',
  17      'CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES',
  18      'CRYPTO_AEAD_CHACHA20POLY1305_NSECBYTES',
  19      'CRYPTO_AEAD_CHACHA20POLY1305_NPUBBYTES',
  20      'CRYPTO_AEAD_CHACHA20POLY1305_ABYTES',
  21      'CRYPTO_AEAD_AES256GCM_KEYBYTES',
  22      'CRYPTO_AEAD_AES256GCM_NSECBYTES',
  23      'CRYPTO_AEAD_AES256GCM_NPUBBYTES',
  24      'CRYPTO_AEAD_AES256GCM_ABYTES',
  25      'CRYPTO_AEAD_CHACHA20POLY1305_IETF_KEYBYTES',
  26      'CRYPTO_AEAD_CHACHA20POLY1305_IETF_NSECBYTES',
  27      'CRYPTO_AEAD_CHACHA20POLY1305_IETF_NPUBBYTES',
  28      'CRYPTO_AEAD_CHACHA20POLY1305_IETF_ABYTES',
  29      'CRYPTO_AEAD_XCHACHA20POLY1305_IETF_KEYBYTES',
  30      'CRYPTO_AEAD_XCHACHA20POLY1305_IETF_NSECBYTES',
  31      'CRYPTO_AEAD_XCHACHA20POLY1305_IETF_NPUBBYTES',
  32      'CRYPTO_AEAD_XCHACHA20POLY1305_IETF_ABYTES',
  33      'CRYPTO_AUTH_BYTES',
  34      'CRYPTO_AUTH_KEYBYTES',
  35      'CRYPTO_BOX_SEALBYTES',
  36      'CRYPTO_BOX_SECRETKEYBYTES',
  37      'CRYPTO_BOX_PUBLICKEYBYTES',
  38      'CRYPTO_BOX_KEYPAIRBYTES',
  39      'CRYPTO_BOX_MACBYTES',
  40      'CRYPTO_BOX_NONCEBYTES',
  41      'CRYPTO_BOX_SEEDBYTES',
  42      'CRYPTO_KDF_BYTES_MIN',
  43      'CRYPTO_KDF_BYTES_MAX',
  44      'CRYPTO_KDF_CONTEXTBYTES',
  45      'CRYPTO_KDF_KEYBYTES',
  46      'CRYPTO_KX_BYTES',
  47      'CRYPTO_KX_KEYPAIRBYTES',
  48      'CRYPTO_KX_PRIMITIVE',
  49      'CRYPTO_KX_SEEDBYTES',
  50      'CRYPTO_KX_PUBLICKEYBYTES',
  51      'CRYPTO_KX_SECRETKEYBYTES',
  52      'CRYPTO_KX_SESSIONKEYBYTES',
  53      'CRYPTO_GENERICHASH_BYTES',
  54      'CRYPTO_GENERICHASH_BYTES_MIN',
  55      'CRYPTO_GENERICHASH_BYTES_MAX',
  56      'CRYPTO_GENERICHASH_KEYBYTES',
  57      'CRYPTO_GENERICHASH_KEYBYTES_MIN',
  58      'CRYPTO_GENERICHASH_KEYBYTES_MAX',
  59      'CRYPTO_PWHASH_SALTBYTES',
  60      'CRYPTO_PWHASH_STRPREFIX',
  61      'CRYPTO_PWHASH_ALG_ARGON2I13',
  62      'CRYPTO_PWHASH_ALG_ARGON2ID13',
  63      'CRYPTO_PWHASH_MEMLIMIT_INTERACTIVE',
  64      'CRYPTO_PWHASH_OPSLIMIT_INTERACTIVE',
  65      'CRYPTO_PWHASH_MEMLIMIT_MODERATE',
  66      'CRYPTO_PWHASH_OPSLIMIT_MODERATE',
  67      'CRYPTO_PWHASH_MEMLIMIT_SENSITIVE',
  68      'CRYPTO_PWHASH_OPSLIMIT_SENSITIVE',
  69      'CRYPTO_PWHASH_SCRYPTSALSA208SHA256_SALTBYTES',
  70      'CRYPTO_PWHASH_SCRYPTSALSA208SHA256_STRPREFIX',
  71      'CRYPTO_PWHASH_SCRYPTSALSA208SHA256_MEMLIMIT_INTERACTIVE',
  72      'CRYPTO_PWHASH_SCRYPTSALSA208SHA256_OPSLIMIT_INTERACTIVE',
  73      'CRYPTO_PWHASH_SCRYPTSALSA208SHA256_MEMLIMIT_SENSITIVE',
  74      'CRYPTO_PWHASH_SCRYPTSALSA208SHA256_OPSLIMIT_SENSITIVE',
  75      'CRYPTO_SCALARMULT_BYTES',
  76      'CRYPTO_SCALARMULT_SCALARBYTES',
  77      'CRYPTO_SHORTHASH_BYTES',
  78      'CRYPTO_SHORTHASH_KEYBYTES',
  79      'CRYPTO_SECRETBOX_KEYBYTES',
  80      'CRYPTO_SECRETBOX_MACBYTES',
  81      'CRYPTO_SECRETBOX_NONCEBYTES',
  82      'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_ABYTES',
  83      'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_HEADERBYTES',
  84      'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_KEYBYTES',
  85      'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_PUSH',
  86      'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_PULL',
  87      'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_REKEY',
  88      'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_FINAL',
  89      'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_MESSAGEBYTES_MAX',
  90      'CRYPTO_SIGN_BYTES',
  91      'CRYPTO_SIGN_SEEDBYTES',
  92      'CRYPTO_SIGN_PUBLICKEYBYTES',
  93      'CRYPTO_SIGN_SECRETKEYBYTES',
  94      'CRYPTO_SIGN_KEYPAIRBYTES',
  95      'CRYPTO_STREAM_KEYBYTES',
  96      'CRYPTO_STREAM_NONCEBYTES',
  97      'CRYPTO_STREAM_XCHACHA20_KEYBYTES',
  98      'CRYPTO_STREAM_XCHACHA20_NONCEBYTES',
  99      'LIBRARY_MAJOR_VERSION',
 100      'LIBRARY_MINOR_VERSION',
 101      'LIBRARY_VERSION_MAJOR',
 102      'LIBRARY_VERSION_MINOR',
 103      'VERSION_STRING'
 104      ) as $constant
 105  ) {
 106      if (!defined("SODIUM_$constant") && defined("ParagonIE_Sodium_Compat::$constant")) {
 107          define("SODIUM_$constant", constant("ParagonIE_Sodium_Compat::$constant"));
 108      }
 109  }
 110  if (!is_callable('sodium_add')) {
 111      /**
 112       * @see ParagonIE_Sodium_Compat::add()
 113       * @param string $val
 114       * @param string $addv
 115       * @return void
 116       * @throws SodiumException
 117       */
 118      function sodium_add(&$val, $addv)
 119      {
 120          ParagonIE_Sodium_Compat::add($val, $addv);
 121      }
 122  }
 123  if (!is_callable('sodium_base642bin')) {
 124      /**
 125       * @see ParagonIE_Sodium_Compat::bin2base64()
 126       * @param string $string
 127       * @param int $variant
 128       * @param string $ignore
 129       * @return string
 130       * @throws SodiumException
 131       * @throws TypeError
 132       */
 133      function sodium_base642bin($string, $variant, $ignore ='')
 134      {
 135          return ParagonIE_Sodium_Compat::base642bin($string, $variant, $ignore);
 136      }
 137  }
 138  if (!is_callable('sodium_bin2base64')) {
 139      /**
 140       * @see ParagonIE_Sodium_Compat::bin2base64()
 141       * @param string $string
 142       * @param int $variant
 143       * @return string
 144       * @throws SodiumException
 145       * @throws TypeError
 146       */
 147      function sodium_bin2base64($string, $variant)
 148      {
 149          return ParagonIE_Sodium_Compat::bin2base64($string, $variant);
 150      }
 151  }
 152  if (!is_callable('sodium_bin2hex')) {
 153      /**
 154       * @see ParagonIE_Sodium_Compat::hex2bin()
 155       * @param string $string
 156       * @return string
 157       * @throws SodiumException
 158       * @throws TypeError
 159       */
 160      function sodium_bin2hex($string)
 161      {
 162          return ParagonIE_Sodium_Compat::bin2hex($string);
 163      }
 164  }
 165  if (!is_callable('sodium_compare')) {
 166      /**
 167       * @see ParagonIE_Sodium_Compat::compare()
 168       * @param string $a
 169       * @param string $b
 170       * @return int
 171       * @throws SodiumException
 172       * @throws TypeError
 173       */
 174      function sodium_compare($a, $b)
 175      {
 176          return ParagonIE_Sodium_Compat::compare($a, $b);
 177      }
 178  }
 179  if (!is_callable('sodium_crypto_aead_aes256gcm_decrypt')) {
 180      /**
 181       * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt()
 182       * @param string $message
 183       * @param string $assocData
 184       * @param string $nonce
 185       * @param string $key
 186       * @return string|bool
 187       */
 188      function sodium_crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key)
 189      {
 190          try {
 191              return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key);
 192          } catch (Error $ex) {
 193              return false;
 194          } catch (Exception $ex) {
 195              return false;
 196          }
 197      }
 198  }
 199  if (!is_callable('sodium_crypto_aead_aes256gcm_encrypt')) {
 200      /**
 201       * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt()
 202       * @param string $message
 203       * @param string $assocData
 204       * @param string $nonce
 205       * @param string $key
 206       * @return string
 207       * @throws SodiumException
 208       * @throws TypeError
 209       */
 210      function sodium_crypto_aead_aes256gcm_encrypt($message, $assocData, $nonce, $key)
 211      {
 212          return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt($message, $assocData, $nonce, $key);
 213      }
 214  }
 215  if (!is_callable('sodium_crypto_aead_aes256gcm_is_available')) {
 216      /**
 217       * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_is_available()
 218       * @return bool
 219       */
 220      function sodium_crypto_aead_aes256gcm_is_available()
 221      {
 222          return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_is_available();
 223      }
 224  }
 225  if (!is_callable('sodium_crypto_aead_chacha20poly1305_decrypt')) {
 226      /**
 227       * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt()
 228       * @param string $message
 229       * @param string $assocData
 230       * @param string $nonce
 231       * @param string $key
 232       * @return string|bool
 233       */
 234      function sodium_crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key)
 235      {
 236          try {
 237              return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key);
 238          } catch (Error $ex) {
 239              return false;
 240          } catch (Exception $ex) {
 241              return false;
 242          }
 243      }
 244  }
 245  if (!is_callable('sodium_crypto_aead_chacha20poly1305_encrypt')) {
 246      /**
 247       * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt()
 248       * @param string $message
 249       * @param string $assocData
 250       * @param string $nonce
 251       * @param string $key
 252       * @return string
 253       * @throws SodiumException
 254       * @throws TypeError
 255       */
 256      function sodium_crypto_aead_chacha20poly1305_encrypt($message, $assocData, $nonce, $key)
 257      {
 258          return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt($message, $assocData, $nonce, $key);
 259      }
 260  }
 261  if (!is_callable('sodium_crypto_aead_chacha20poly1305_keygen')) {
 262      /**
 263       * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_keygen()
 264       * @return string
 265       * @throws Exception
 266       */
 267      function sodium_crypto_aead_chacha20poly1305_keygen()
 268      {
 269          return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_keygen();
 270      }
 271  }
 272  if (!is_callable('sodium_crypto_aead_chacha20poly1305_ietf_decrypt')) {
 273      /**
 274       * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt()
 275       * @param string $message
 276       * @param string $assocData
 277       * @param string $nonce
 278       * @param string $key
 279       * @return string|bool
 280       */
 281      function sodium_crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key)
 282      {
 283          try {
 284              return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key);
 285          } catch (Error $ex) {
 286              return false;
 287          } catch (Exception $ex) {
 288              return false;
 289          }
 290      }
 291  }
 292  if (!is_callable('sodium_crypto_aead_chacha20poly1305_ietf_encrypt')) {
 293      /**
 294       * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt()
 295       * @param string $message
 296       * @param string $assocData
 297       * @param string $nonce
 298       * @param string $key
 299       * @return string
 300       * @throws SodiumException
 301       * @throws TypeError
 302       */
 303      function sodium_crypto_aead_chacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key)
 304      {
 305          return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key);
 306      }
 307  }
 308  if (!is_callable('sodium_crypto_aead_chacha20poly1305_ietf_keygen')) {
 309      /**
 310       * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_keygen()
 311       * @return string
 312       * @throws Exception
 313       */
 314      function sodium_crypto_aead_chacha20poly1305_ietf_keygen()
 315      {
 316          return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_keygen();
 317      }
 318  }
 319  if (!is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_decrypt')) {
 320      /**
 321       * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_decrypt()
 322       * @param string $message
 323       * @param string $assocData
 324       * @param string $nonce
 325       * @param string $key
 326       * @return string|bool
 327       */
 328      function sodium_crypto_aead_xchacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key)
 329      {
 330          try {
 331              return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key, true);
 332          } catch (Error $ex) {
 333              return false;
 334          } catch (Exception $ex) {
 335              return false;
 336          }
 337      }
 338  }
 339  if (!is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_encrypt')) {
 340      /**
 341       * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_encrypt()
 342       * @param string $message
 343       * @param string $assocData
 344       * @param string $nonce
 345       * @param string $key
 346       * @return string
 347       * @throws SodiumException
 348       * @throws TypeError
 349       */
 350      function sodium_crypto_aead_xchacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key)
 351      {
 352          return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key, true);
 353      }
 354  }
 355  if (!is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_keygen')) {
 356      /**
 357       * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_keygen()
 358       * @return string
 359       * @throws Exception
 360       */
 361      function sodium_crypto_aead_xchacha20poly1305_ietf_keygen()
 362      {
 363          return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_keygen();
 364      }
 365  }
 366  if (!is_callable('sodium_crypto_auth')) {
 367      /**
 368       * @see ParagonIE_Sodium_Compat::crypto_auth()
 369       * @param string $message
 370       * @param string $key
 371       * @return string
 372       * @throws SodiumException
 373       * @throws TypeError
 374       */
 375      function sodium_crypto_auth($message, $key)
 376      {
 377          return ParagonIE_Sodium_Compat::crypto_auth($message, $key);
 378      }
 379  }
 380  if (!is_callable('sodium_crypto_auth_keygen')) {
 381      /**
 382       * @see ParagonIE_Sodium_Compat::crypto_auth_keygen()
 383       * @return string
 384       * @throws Exception
 385       */
 386      function sodium_crypto_auth_keygen()
 387      {
 388          return ParagonIE_Sodium_Compat::crypto_auth_keygen();
 389      }
 390  }
 391  if (!is_callable('sodium_crypto_auth_verify')) {
 392      /**
 393       * @see ParagonIE_Sodium_Compat::crypto_auth_verify()
 394       * @param string $mac
 395       * @param string $message
 396       * @param string $key
 397       * @return bool
 398       * @throws SodiumException
 399       * @throws TypeError
 400       */
 401      function sodium_crypto_auth_verify($mac, $message, $key)
 402      {
 403          return ParagonIE_Sodium_Compat::crypto_auth_verify($mac, $message, $key);
 404      }
 405  }
 406  if (!is_callable('sodium_crypto_box')) {
 407      /**
 408       * @see ParagonIE_Sodium_Compat::crypto_box()
 409       * @param string $message
 410       * @param string $nonce
 411       * @param string $kp
 412       * @return string
 413       * @throws SodiumException
 414       * @throws TypeError
 415       */
 416      function sodium_crypto_box($message, $nonce, $kp)
 417      {
 418          return ParagonIE_Sodium_Compat::crypto_box($message, $nonce, $kp);
 419      }
 420  }
 421  if (!is_callable('sodium_crypto_box_keypair')) {
 422      /**
 423       * @see ParagonIE_Sodium_Compat::crypto_box_keypair()
 424       * @return string
 425       * @throws SodiumException
 426       * @throws TypeError
 427       */
 428      function sodium_crypto_box_keypair()
 429      {
 430          return ParagonIE_Sodium_Compat::crypto_box_keypair();
 431      }
 432  }
 433  if (!is_callable('sodium_crypto_box_keypair_from_secretkey_and_publickey')) {
 434      /**
 435       * @see ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey()
 436       * @param string $sk
 437       * @param string $pk
 438       * @return string
 439       * @throws SodiumException
 440       * @throws TypeError
 441       */
 442      function sodium_crypto_box_keypair_from_secretkey_and_publickey($sk, $pk)
 443      {
 444          return ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey($sk, $pk);
 445      }
 446  }
 447  if (!is_callable('sodium_crypto_box_open')) {
 448      /**
 449       * @see ParagonIE_Sodium_Compat::crypto_box_open()
 450       * @param string $message
 451       * @param string $nonce
 452       * @param string $kp
 453       * @return string|bool
 454       */
 455      function sodium_crypto_box_open($message, $nonce, $kp)
 456      {
 457          try {
 458              return ParagonIE_Sodium_Compat::crypto_box_open($message, $nonce, $kp);
 459          } catch (Error $ex) {
 460              return false;
 461          } catch (Exception $ex) {
 462              return false;
 463          }
 464      }
 465  }
 466  if (!is_callable('sodium_crypto_box_publickey')) {
 467      /**
 468       * @see ParagonIE_Sodium_Compat::crypto_box_publickey()
 469       * @param string $keypair
 470       * @return string
 471       * @throws SodiumException
 472       * @throws TypeError
 473       */
 474      function sodium_crypto_box_publickey($keypair)
 475      {
 476          return ParagonIE_Sodium_Compat::crypto_box_publickey($keypair);
 477      }
 478  }
 479  if (!is_callable('sodium_crypto_box_publickey_from_secretkey')) {
 480      /**
 481       * @see ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey()
 482       * @param string $sk
 483       * @return string
 484       * @throws SodiumException
 485       * @throws TypeError
 486       */
 487      function sodium_crypto_box_publickey_from_secretkey($sk)
 488      {
 489          return ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey($sk);
 490      }
 491  }
 492  if (!is_callable('sodium_crypto_box_seal')) {
 493      /**
 494       * @see ParagonIE_Sodium_Compat::crypto_box_seal()
 495       * @param string $message
 496       * @param string $publicKey
 497       * @return string
 498       * @throws SodiumException
 499       * @throws TypeError
 500       */
 501      function sodium_crypto_box_seal($message, $publicKey)
 502      {
 503          return ParagonIE_Sodium_Compat::crypto_box_seal($message, $publicKey);
 504      }
 505  }
 506  if (!is_callable('sodium_crypto_box_seal_open')) {
 507      /**
 508       * @see ParagonIE_Sodium_Compat::crypto_box_seal_open()
 509       * @param string $message
 510       * @param string $kp
 511       * @return string|bool
 512       * @throws SodiumException
 513       */
 514      function sodium_crypto_box_seal_open($message, $kp)
 515      {
 516          try {
 517              return ParagonIE_Sodium_Compat::crypto_box_seal_open($message, $kp);
 518          } catch (SodiumException $ex) {
 519              if ($ex->getMessage() === 'Argument 2 must be CRYPTO_BOX_KEYPAIRBYTES long.') {
 520                  throw $ex;
 521              }
 522              return false;
 523          }
 524      }
 525  }
 526  if (!is_callable('sodium_crypto_box_secretkey')) {
 527      /**
 528       * @see ParagonIE_Sodium_Compat::crypto_box_secretkey()
 529       * @param string $keypair
 530       * @return string
 531       * @throws SodiumException
 532       * @throws TypeError
 533       */
 534      function sodium_crypto_box_secretkey($keypair)
 535      {
 536          return ParagonIE_Sodium_Compat::crypto_box_secretkey($keypair);
 537      }
 538  }
 539  if (!is_callable('sodium_crypto_box_seed_keypair')) {
 540      /**
 541       * @see ParagonIE_Sodium_Compat::crypto_box_seed_keypair()
 542       * @param string $seed
 543       * @return string
 544       * @throws SodiumException
 545       * @throws TypeError
 546       */
 547      function sodium_crypto_box_seed_keypair($seed)
 548      {
 549          return ParagonIE_Sodium_Compat::crypto_box_seed_keypair($seed);
 550      }
 551  }
 552  if (!is_callable('sodium_crypto_generichash')) {
 553      /**
 554       * @see ParagonIE_Sodium_Compat::crypto_generichash()
 555       * @param string $message
 556       * @param string|null $key
 557       * @param int $outLen
 558       * @return string
 559       * @throws SodiumException
 560       * @throws TypeError
 561       */
 562      function sodium_crypto_generichash($message, $key = null, $outLen = 32)
 563      {
 564          return ParagonIE_Sodium_Compat::crypto_generichash($message, $key, $outLen);
 565      }
 566  }
 567  if (!is_callable('sodium_crypto_generichash_final')) {
 568      /**
 569       * @see ParagonIE_Sodium_Compat::crypto_generichash_final()
 570       * @param string|null $ctx
 571       * @param int $outputLength
 572       * @return string
 573       * @throws SodiumException
 574       * @throws TypeError
 575       */
 576      function sodium_crypto_generichash_final(&$ctx, $outputLength = 32)
 577      {
 578          return ParagonIE_Sodium_Compat::crypto_generichash_final($ctx, $outputLength);
 579      }
 580  }
 581  if (!is_callable('sodium_crypto_generichash_init')) {
 582      /**
 583       * @see ParagonIE_Sodium_Compat::crypto_generichash_init()
 584       * @param string|null $key
 585       * @param int $outLen
 586       * @return string
 587       * @throws SodiumException
 588       * @throws TypeError
 589       */
 590      function sodium_crypto_generichash_init($key = null, $outLen = 32)
 591      {
 592          return ParagonIE_Sodium_Compat::crypto_generichash_init($key, $outLen);
 593      }
 594  }
 595  if (!is_callable('sodium_crypto_generichash_keygen')) {
 596      /**
 597       * @see ParagonIE_Sodium_Compat::crypto_generichash_keygen()
 598       * @return string
 599       * @throws Exception
 600       */
 601      function sodium_crypto_generichash_keygen()
 602      {
 603          return ParagonIE_Sodium_Compat::crypto_generichash_keygen();
 604      }
 605  }
 606  if (!is_callable('sodium_crypto_generichash_update')) {
 607      /**
 608       * @see ParagonIE_Sodium_Compat::crypto_generichash_update()
 609       * @param string|null $ctx
 610       * @param string $message
 611       * @return void
 612       * @throws SodiumException
 613       * @throws TypeError
 614       */
 615      function sodium_crypto_generichash_update(&$ctx, $message = '')
 616      {
 617          ParagonIE_Sodium_Compat::crypto_generichash_update($ctx, $message);
 618      }
 619  }
 620  if (!is_callable('sodium_crypto_kdf_keygen')) {
 621      /**
 622       * @see ParagonIE_Sodium_Compat::crypto_kdf_keygen()
 623       * @return string
 624       * @throws Exception
 625       */
 626      function sodium_crypto_kdf_keygen()
 627      {
 628          return ParagonIE_Sodium_Compat::crypto_kdf_keygen();
 629      }
 630  }
 631  if (!is_callable('sodium_crypto_kdf_derive_from_key')) {
 632      /**
 633       * @see ParagonIE_Sodium_Compat::crypto_kdf_derive_from_key()
 634       * @param int $subkey_len
 635       * @param int $subkey_id
 636       * @param string $context
 637       * @param string $key
 638       * @return string
 639       * @throws Exception
 640       */
 641      function sodium_crypto_kdf_derive_from_key($subkey_len, $subkey_id, $context, $key)
 642      {
 643          return ParagonIE_Sodium_Compat::crypto_kdf_derive_from_key(
 644              $subkey_len,
 645              $subkey_id,
 646              $context,
 647              $key
 648          );
 649      }
 650  }
 651  if (!is_callable('sodium_crypto_kx')) {
 652      /**
 653       * @see ParagonIE_Sodium_Compat::crypto_kx()
 654       * @param string $my_secret
 655       * @param string $their_public
 656       * @param string $client_public
 657       * @param string $server_public
 658       * @return string
 659       * @throws SodiumException
 660       * @throws TypeError
 661       */
 662      function sodium_crypto_kx($my_secret, $their_public, $client_public, $server_public)
 663      {
 664          return ParagonIE_Sodium_Compat::crypto_kx(
 665              $my_secret,
 666              $their_public,
 667              $client_public,
 668              $server_public
 669          );
 670      }
 671  }
 672  if (!is_callable('sodium_crypto_kx_seed_keypair')) {
 673      /**
 674       * @param string $seed
 675       * @return string
 676       * @throws Exception
 677       */
 678      function sodium_crypto_kx_seed_keypair($seed)
 679      {
 680          return ParagonIE_Sodium_Compat::crypto_kx_seed_keypair($seed);
 681      }
 682  }
 683  if (!is_callable('sodium_crypto_kx_keypair')) {
 684      /**
 685       * @return string
 686       * @throws Exception
 687       */
 688      function sodium_crypto_kx_keypair()
 689      {
 690          return ParagonIE_Sodium_Compat::crypto_kx_keypair();
 691      }
 692  }
 693  if (!is_callable('sodium_crypto_kx_client_session_keys')) {
 694      /**
 695       * @param string $keypair
 696       * @param string $serverPublicKey
 697       * @return array{0: string, 1: string}
 698       * @throws SodiumException
 699       */
 700      function sodium_crypto_kx_client_session_keys($keypair, $serverPublicKey)
 701      {
 702          return ParagonIE_Sodium_Compat::crypto_kx_client_session_keys($keypair, $serverPublicKey);
 703      }
 704  }
 705  if (!is_callable('sodium_crypto_kx_server_session_keys')) {
 706      /**
 707       * @param string $keypair
 708       * @param string $clientPublicKey
 709       * @return array{0: string, 1: string}
 710       * @throws SodiumException
 711       */
 712      function sodium_crypto_kx_server_session_keys($keypair, $clientPublicKey)
 713      {
 714          return ParagonIE_Sodium_Compat::crypto_kx_server_session_keys($keypair, $clientPublicKey);
 715      }
 716  }
 717  if (!is_callable('sodium_crypto_kx_secretkey')) {
 718      /**
 719       * @param string $keypair
 720       * @return string
 721       * @throws Exception
 722       */
 723      function sodium_crypto_kx_secretkey($keypair)
 724      {
 725          return ParagonIE_Sodium_Compat::crypto_kx_secretkey($keypair);
 726      }
 727  }
 728  if (!is_callable('sodium_crypto_kx_publickey')) {
 729      /**
 730       * @param string $keypair
 731       * @return string
 732       * @throws Exception
 733       */
 734      function sodium_crypto_kx_publickey($keypair)
 735      {
 736          return ParagonIE_Sodium_Compat::crypto_kx_publickey($keypair);
 737      }
 738  }
 739  if (!is_callable('sodium_crypto_pwhash')) {
 740      /**
 741       * @see ParagonIE_Sodium_Compat::crypto_pwhash()
 742       * @param int $outlen
 743       * @param string $passwd
 744       * @param string $salt
 745       * @param int $opslimit
 746       * @param int $memlimit
 747       * @param int|null $algo
 748       * @return string
 749       * @throws SodiumException
 750       * @throws TypeError
 751       */
 752      function sodium_crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit, $algo = null)
 753      {
 754          return ParagonIE_Sodium_Compat::crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit, $algo);
 755      }
 756  }
 757  if (!is_callable('sodium_crypto_pwhash_str')) {
 758      /**
 759       * @see ParagonIE_Sodium_Compat::crypto_pwhash_str()
 760       * @param string $passwd
 761       * @param int $opslimit
 762       * @param int $memlimit
 763       * @return string
 764       * @throws SodiumException
 765       * @throws TypeError
 766       */
 767      function sodium_crypto_pwhash_str($passwd, $opslimit, $memlimit)
 768      {
 769          return ParagonIE_Sodium_Compat::crypto_pwhash_str($passwd, $opslimit, $memlimit);
 770      }
 771  }
 772  if (!is_callable('sodium_crypto_pwhash_str_needs_rehash')) {
 773      /**
 774       * @see ParagonIE_Sodium_Compat::crypto_pwhash_str_needs_rehash()
 775       * @param string $hash
 776       * @param int $opslimit
 777       * @param int $memlimit
 778       * @return bool
 779       *
 780       * @throws SodiumException
 781       */
 782      function sodium_crypto_pwhash_str_needs_rehash($hash, $opslimit, $memlimit)
 783      {
 784          return ParagonIE_Sodium_Compat::crypto_pwhash_str_needs_rehash($hash, $opslimit, $memlimit);
 785      }
 786  }
 787  if (!is_callable('sodium_crypto_pwhash_str_verify')) {
 788      /**
 789       * @see ParagonIE_Sodium_Compat::crypto_pwhash_str_verify()
 790       * @param string $passwd
 791       * @param string $hash
 792       * @return bool
 793       * @throws SodiumException
 794       * @throws TypeError
 795       */
 796      function sodium_crypto_pwhash_str_verify($passwd, $hash)
 797      {
 798          return ParagonIE_Sodium_Compat::crypto_pwhash_str_verify($passwd, $hash);
 799      }
 800  }
 801  if (!is_callable('sodium_crypto_pwhash_scryptsalsa208sha256')) {
 802      /**
 803       * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256()
 804       * @param int $outlen
 805       * @param string $passwd
 806       * @param string $salt
 807       * @param int $opslimit
 808       * @param int $memlimit
 809       * @return string
 810       * @throws SodiumException
 811       * @throws TypeError
 812       */
 813      function sodium_crypto_pwhash_scryptsalsa208sha256($outlen, $passwd, $salt, $opslimit, $memlimit)
 814      {
 815          return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256($outlen, $passwd, $salt, $opslimit, $memlimit);
 816      }
 817  }
 818  if (!is_callable('sodium_crypto_pwhash_scryptsalsa208sha256_str')) {
 819      /**
 820       * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str()
 821       * @param string $passwd
 822       * @param int $opslimit
 823       * @param int $memlimit
 824       * @return string
 825       * @throws SodiumException
 826       * @throws TypeError
 827       */
 828      function sodium_crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit)
 829      {
 830          return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit);
 831      }
 832  }
 833  if (!is_callable('sodium_crypto_pwhash_scryptsalsa208sha256_str_verify')) {
 834      /**
 835       * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str_verify()
 836       * @param string $passwd
 837       * @param string $hash
 838       * @return bool
 839       * @throws SodiumException
 840       * @throws TypeError
 841       */
 842      function sodium_crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash)
 843      {
 844          return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash);
 845      }
 846  }
 847  if (!is_callable('sodium_crypto_scalarmult')) {
 848      /**
 849       * @see ParagonIE_Sodium_Compat::crypto_scalarmult()
 850       * @param string $n
 851       * @param string $p
 852       * @return string
 853       * @throws SodiumException
 854       * @throws TypeError
 855       */
 856      function sodium_crypto_scalarmult($n, $p)
 857      {
 858          return ParagonIE_Sodium_Compat::crypto_scalarmult($n, $p);
 859      }
 860  }
 861  if (!is_callable('sodium_crypto_scalarmult_base')) {
 862      /**
 863       * @see ParagonIE_Sodium_Compat::crypto_scalarmult_base()
 864       * @param string $n
 865       * @return string
 866       * @throws SodiumException
 867       * @throws TypeError
 868       */
 869      function sodium_crypto_scalarmult_base($n)
 870      {
 871          return ParagonIE_Sodium_Compat::crypto_scalarmult_base($n);
 872      }
 873  }
 874  if (!is_callable('sodium_crypto_secretbox')) {
 875      /**
 876       * @see ParagonIE_Sodium_Compat::crypto_secretbox()
 877       * @param string $message
 878       * @param string $nonce
 879       * @param string $key
 880       * @return string
 881       * @throws SodiumException
 882       * @throws TypeError
 883       */
 884      function sodium_crypto_secretbox($message, $nonce, $key)
 885      {
 886          return ParagonIE_Sodium_Compat::crypto_secretbox($message, $nonce, $key);
 887      }
 888  }
 889  if (!is_callable('sodium_crypto_secretbox_keygen')) {
 890      /**
 891       * @see ParagonIE_Sodium_Compat::crypto_secretbox_keygen()
 892       * @return string
 893       * @throws Exception
 894       */
 895      function sodium_crypto_secretbox_keygen()
 896      {
 897          return ParagonIE_Sodium_Compat::crypto_secretbox_keygen();
 898      }
 899  }
 900  if (!is_callable('sodium_crypto_secretbox_open')) {
 901      /**
 902       * @see ParagonIE_Sodium_Compat::crypto_secretbox_open()
 903       * @param string $message
 904       * @param string $nonce
 905       * @param string $key
 906       * @return string|bool
 907       */
 908      function sodium_crypto_secretbox_open($message, $nonce, $key)
 909      {
 910          try {
 911              return ParagonIE_Sodium_Compat::crypto_secretbox_open($message, $nonce, $key);
 912          } catch (Error $ex) {
 913              return false;
 914          } catch (Exception $ex) {
 915              return false;
 916          }
 917      }
 918  }
 919  if (!is_callable('sodium_crypto_secretstream_xchacha20poly1305_init_push')) {
 920      /**
 921       * @param string $key
 922       * @return array<int, string>
 923       * @throws SodiumException
 924       */
 925      function sodium_crypto_secretstream_xchacha20poly1305_init_push($key)
 926      {
 927          return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_init_push($key);
 928      }
 929  }
 930  if (!is_callable('sodium_crypto_secretstream_xchacha20poly1305_push')) {
 931      /**
 932       * @param string $state
 933       * @param string $msg
 934       * @param string $aad
 935       * @param int $tag
 936       * @return string
 937       * @throws SodiumException
 938       */
 939      function sodium_crypto_secretstream_xchacha20poly1305_push(&$state, $msg, $aad = '', $tag = 0)
 940      {
 941          return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_push($state, $msg, $aad, $tag);
 942      }
 943  }
 944  if (!is_callable('sodium_crypto_secretstream_xchacha20poly1305_init_pull')) {
 945      /**
 946       * @param string $header
 947       * @param string $key
 948       * @return string
 949       * @throws Exception
 950       */
 951      function sodium_crypto_secretstream_xchacha20poly1305_init_pull($header, $key)
 952      {
 953          return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_init_pull($header, $key);
 954      }
 955  }
 956  if (!is_callable('sodium_crypto_secretstream_xchacha20poly1305_pull')) {
 957      /**
 958       * @param string $state
 959       * @param string $cipher
 960       * @param string $aad
 961       * @return bool|array{0: string, 1: int}
 962       * @throws SodiumException
 963       */
 964      function sodium_crypto_secretstream_xchacha20poly1305_pull(&$state, $cipher, $aad = '')
 965      {
 966          return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_pull($state, $cipher, $aad);
 967      }
 968  }
 969  if (!is_callable('sodium_crypto_secretstream_xchacha20poly1305_rekey')) {
 970      /**
 971       * @param string $state
 972       * @return void
 973       * @throws SodiumException
 974       */
 975      function sodium_crypto_secretstream_xchacha20poly1305_rekey(&$state)
 976      {
 977          ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_rekey($state);
 978      }
 979  }
 980  if (!is_callable('sodium_crypto_secretstream_xchacha20poly1305_keygen')) {
 981      /**
 982       * @return string
 983       * @throws Exception
 984       */
 985      function sodium_crypto_secretstream_xchacha20poly1305_keygen()
 986      {
 987          return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_keygen();
 988      }
 989  }
 990  if (!is_callable('sodium_crypto_shorthash')) {
 991      /**
 992       * @see ParagonIE_Sodium_Compat::crypto_shorthash()
 993       * @param string $message
 994       * @param string $key
 995       * @return string
 996       * @throws SodiumException
 997       * @throws TypeError
 998       */
 999      function sodium_crypto_shorthash($message, $key = '')
1000      {
1001          return ParagonIE_Sodium_Compat::crypto_shorthash($message, $key);
1002      }
1003  }
1004  if (!is_callable('sodium_crypto_shorthash_keygen')) {
1005      /**
1006       * @see ParagonIE_Sodium_Compat::crypto_shorthash_keygen()
1007       * @return string
1008       * @throws Exception
1009       */
1010      function sodium_crypto_shorthash_keygen()
1011      {
1012          return ParagonIE_Sodium_Compat::crypto_shorthash_keygen();
1013      }
1014  }
1015  if (!is_callable('sodium_crypto_sign')) {
1016      /**
1017       * @see ParagonIE_Sodium_Compat::crypto_sign()
1018       * @param string $message
1019       * @param string $sk
1020       * @return string
1021       * @throws SodiumException
1022       * @throws TypeError
1023       */
1024      function sodium_crypto_sign($message, $sk)
1025      {
1026          return ParagonIE_Sodium_Compat::crypto_sign($message, $sk);
1027      }
1028  }
1029  if (!is_callable('sodium_crypto_sign_detached')) {
1030      /**
1031       * @see ParagonIE_Sodium_Compat::crypto_sign_detached()
1032       * @param string $message
1033       * @param string $sk
1034       * @return string
1035       * @throws SodiumException
1036       * @throws TypeError
1037       */
1038      function sodium_crypto_sign_detached($message, $sk)
1039      {
1040          return ParagonIE_Sodium_Compat::crypto_sign_detached($message, $sk);
1041      }
1042  }
1043  if (!is_callable('sodium_crypto_sign_keypair_from_secretkey_and_publickey')) {
1044      /**
1045       * @see ParagonIE_Sodium_Compat::crypto_sign_keypair_from_secretkey_and_publickey()
1046       * @param string $sk
1047       * @param string $pk
1048       * @return string
1049       * @throws SodiumException
1050       * @throws TypeError
1051       */
1052      function sodium_crypto_sign_keypair_from_secretkey_and_publickey($sk, $pk)
1053      {
1054          return ParagonIE_Sodium_Compat::crypto_sign_keypair_from_secretkey_and_publickey($sk, $pk);
1055      }
1056  }
1057  if (!is_callable('sodium_crypto_sign_keypair')) {
1058      /**
1059       * @see ParagonIE_Sodium_Compat::crypto_sign_keypair()
1060       * @return string
1061       * @throws SodiumException
1062       * @throws TypeError
1063       */
1064      function sodium_crypto_sign_keypair()
1065      {
1066          return ParagonIE_Sodium_Compat::crypto_sign_keypair();
1067      }
1068  }
1069  if (!is_callable('sodium_crypto_sign_open')) {
1070      /**
1071       * @see ParagonIE_Sodium_Compat::crypto_sign_open()
1072       * @param string $signedMessage
1073       * @param string $pk
1074       * @return string|bool
1075       */
1076      function sodium_crypto_sign_open($signedMessage, $pk)
1077      {
1078          try {
1079              return ParagonIE_Sodium_Compat::crypto_sign_open($signedMessage, $pk);
1080          } catch (Error $ex) {
1081              return false;
1082          } catch (Exception $ex) {
1083              return false;
1084          }
1085      }
1086  }
1087  if (!is_callable('sodium_crypto_sign_publickey')) {
1088      /**
1089       * @see ParagonIE_Sodium_Compat::crypto_sign_publickey()
1090       * @param string $keypair
1091       * @return string
1092       * @throws SodiumException
1093       * @throws TypeError
1094       */
1095      function sodium_crypto_sign_publickey($keypair)
1096      {
1097          return ParagonIE_Sodium_Compat::crypto_sign_publickey($keypair);
1098      }
1099  }
1100  if (!is_callable('sodium_crypto_sign_publickey_from_secretkey')) {
1101      /**
1102       * @see ParagonIE_Sodium_Compat::crypto_sign_publickey_from_secretkey()
1103       * @param string $sk
1104       * @return string
1105       * @throws SodiumException
1106       * @throws TypeError
1107       */
1108      function sodium_crypto_sign_publickey_from_secretkey($sk)
1109      {
1110          return ParagonIE_Sodium_Compat::crypto_sign_publickey_from_secretkey($sk);
1111      }
1112  }
1113  if (!is_callable('sodium_crypto_sign_secretkey')) {
1114      /**
1115       * @see ParagonIE_Sodium_Compat::crypto_sign_secretkey()
1116       * @param string $keypair
1117       * @return string
1118       * @throws SodiumException
1119       * @throws TypeError
1120       */
1121      function sodium_crypto_sign_secretkey($keypair)
1122      {
1123          return ParagonIE_Sodium_Compat::crypto_sign_secretkey($keypair);
1124      }
1125  }
1126  if (!is_callable('sodium_crypto_sign_seed_keypair')) {
1127      /**
1128       * @see ParagonIE_Sodium_Compat::crypto_sign_seed_keypair()
1129       * @param string $seed
1130       * @return string
1131       * @throws SodiumException
1132       * @throws TypeError
1133       */
1134      function sodium_crypto_sign_seed_keypair($seed)
1135      {
1136          return ParagonIE_Sodium_Compat::crypto_sign_seed_keypair($seed);
1137      }
1138  }
1139  if (!is_callable('sodium_crypto_sign_verify_detached')) {
1140      /**
1141       * @see ParagonIE_Sodium_Compat::crypto_sign_verify_detached()
1142       * @param string $signature
1143       * @param string $message
1144       * @param string $pk
1145       * @return bool
1146       * @throws SodiumException
1147       * @throws TypeError
1148       */
1149      function sodium_crypto_sign_verify_detached($signature, $message, $pk)
1150      {
1151          return ParagonIE_Sodium_Compat::crypto_sign_verify_detached($signature, $message, $pk);
1152      }
1153  }
1154  if (!is_callable('sodium_crypto_sign_ed25519_pk_to_curve25519')) {
1155      /**
1156       * @see ParagonIE_Sodium_Compat::crypto_sign_ed25519_pk_to_curve25519()
1157       * @param string $pk
1158       * @return string
1159       * @throws SodiumException
1160       * @throws TypeError
1161       */
1162      function sodium_crypto_sign_ed25519_pk_to_curve25519($pk)
1163      {
1164          return ParagonIE_Sodium_Compat::crypto_sign_ed25519_pk_to_curve25519($pk);
1165      }
1166  }
1167  if (!is_callable('sodium_crypto_sign_ed25519_sk_to_curve25519')) {
1168      /**
1169       * @see ParagonIE_Sodium_Compat::crypto_sign_ed25519_sk_to_curve25519()
1170       * @param string $sk
1171       * @return string
1172       * @throws SodiumException
1173       * @throws TypeError
1174       */
1175      function sodium_crypto_sign_ed25519_sk_to_curve25519($sk)
1176      {
1177          return ParagonIE_Sodium_Compat::crypto_sign_ed25519_sk_to_curve25519($sk);
1178      }
1179  }
1180  if (!is_callable('sodium_crypto_stream')) {
1181      /**
1182       * @see ParagonIE_Sodium_Compat::crypto_stream()
1183       * @param int $len
1184       * @param string $nonce
1185       * @param string $key
1186       * @return string
1187       * @throws SodiumException
1188       * @throws TypeError
1189       */
1190      function sodium_crypto_stream($len, $nonce, $key)
1191      {
1192          return ParagonIE_Sodium_Compat::crypto_stream($len, $nonce, $key);
1193      }
1194  }
1195  if (!is_callable('sodium_crypto_stream_keygen')) {
1196      /**
1197       * @see ParagonIE_Sodium_Compat::crypto_stream_keygen()
1198       * @return string
1199       * @throws Exception
1200       */
1201      function sodium_crypto_stream_keygen()
1202      {
1203          return ParagonIE_Sodium_Compat::crypto_stream_keygen();
1204      }
1205  }
1206  if (!is_callable('sodium_crypto_stream_xor')) {
1207      /**
1208       * @see ParagonIE_Sodium_Compat::crypto_stream_xor()
1209       * @param string $message
1210       * @param string $nonce
1211       * @param string $key
1212       * @return string
1213       * @throws SodiumException
1214       * @throws TypeError
1215       */
1216      function sodium_crypto_stream_xor($message, $nonce, $key)
1217      {
1218          return ParagonIE_Sodium_Compat::crypto_stream_xor($message, $nonce, $key);
1219      }
1220  }
1221  require_once dirname(__FILE__) . '/stream-xchacha20.php';
1222  if (!is_callable('sodium_hex2bin')) {
1223      /**
1224       * @see ParagonIE_Sodium_Compat::hex2bin()
1225       * @param string $string
1226       * @return string
1227       * @throws SodiumException
1228       * @throws TypeError
1229       */
1230      function sodium_hex2bin($string)
1231      {
1232          return ParagonIE_Sodium_Compat::hex2bin($string);
1233      }
1234  }
1235  if (!is_callable('sodium_increment')) {
1236      /**
1237       * @see ParagonIE_Sodium_Compat::increment()
1238       * @param string $string
1239       * @return void
1240       * @throws SodiumException
1241       * @throws TypeError
1242       */
1243      function sodium_increment(&$string)
1244      {
1245          ParagonIE_Sodium_Compat::increment($string);
1246      }
1247  }
1248  if (!is_callable('sodium_library_version_major')) {
1249      /**
1250       * @see ParagonIE_Sodium_Compat::library_version_major()
1251       * @return int
1252       */
1253      function sodium_library_version_major()
1254      {
1255          return ParagonIE_Sodium_Compat::library_version_major();
1256      }
1257  }
1258  if (!is_callable('sodium_library_version_minor')) {
1259      /**
1260       * @see ParagonIE_Sodium_Compat::library_version_minor()
1261       * @return int
1262       */
1263      function sodium_library_version_minor()
1264      {
1265          return ParagonIE_Sodium_Compat::library_version_minor();
1266      }
1267  }
1268  if (!is_callable('sodium_version_string')) {
1269      /**
1270       * @see ParagonIE_Sodium_Compat::version_string()
1271       * @return string
1272       */
1273      function sodium_version_string()
1274      {
1275          return ParagonIE_Sodium_Compat::version_string();
1276      }
1277  }
1278  if (!is_callable('sodium_memcmp')) {
1279      /**
1280       * @see ParagonIE_Sodium_Compat::memcmp()
1281       * @param string $a
1282       * @param string $b
1283       * @return int
1284       * @throws SodiumException
1285       * @throws TypeError
1286       */
1287      function sodium_memcmp($a, $b)
1288      {
1289          return ParagonIE_Sodium_Compat::memcmp($a, $b);
1290      }
1291  }
1292  if (!is_callable('sodium_memzero')) {
1293      /**
1294       * @see ParagonIE_Sodium_Compat::memzero()
1295       * @param string $str
1296       * @return void
1297       * @throws SodiumException
1298       * @throws TypeError
1299       */
1300      function sodium_memzero(&$str)
1301      {
1302          ParagonIE_Sodium_Compat::memzero($str);
1303      }
1304  }
1305  if (!is_callable('sodium_pad')) {
1306      /**
1307       * @see ParagonIE_Sodium_Compat::pad()
1308       * @param string $unpadded
1309       * @param int $blockSize
1310       * @return int
1311       * @throws SodiumException
1312       * @throws TypeError
1313       */
1314      function sodium_pad($unpadded, $blockSize)
1315      {
1316          return ParagonIE_Sodium_Compat::pad($unpadded, $blockSize, true);
1317      }
1318  }
1319  if (!is_callable('sodium_unpad')) {
1320      /**
1321       * @see ParagonIE_Sodium_Compat::pad()
1322       * @param string $padded
1323       * @param int $blockSize
1324       * @return int
1325       * @throws SodiumException
1326       * @throws TypeError
1327       */
1328      function sodium_unpad($padded, $blockSize)
1329      {
1330          return ParagonIE_Sodium_Compat::unpad($padded, $blockSize, true);
1331      }
1332  }
1333  if (!is_callable('sodium_randombytes_buf')) {
1334      /**
1335       * @see ParagonIE_Sodium_Compat::randombytes_buf()
1336       * @param int $amount
1337       * @return string
1338       * @throws Exception
1339       */
1340      function sodium_randombytes_buf($amount)
1341      {
1342          return ParagonIE_Sodium_Compat::randombytes_buf($amount);
1343      }
1344  }
1345  
1346  if (!is_callable('sodium_randombytes_uniform')) {
1347      /**
1348       * @see ParagonIE_Sodium_Compat::randombytes_uniform()
1349       * @param int $upperLimit
1350       * @return int
1351       * @throws Exception
1352       */
1353      function sodium_randombytes_uniform($upperLimit)
1354      {
1355          return ParagonIE_Sodium_Compat::randombytes_uniform($upperLimit);
1356      }
1357  }
1358  
1359  if (!is_callable('sodium_randombytes_random16')) {
1360      /**
1361       * @see ParagonIE_Sodium_Compat::randombytes_random16()
1362       * @return int
1363       * @throws Exception
1364       */
1365      function sodium_randombytes_random16()
1366      {
1367          return ParagonIE_Sodium_Compat::randombytes_random16();
1368      }
1369  }


Generated: Sun Aug 1 01:00:05 2021 Cross-referenced by PHPXref 0.7.1