[Summary view] [Print] [Text view]

   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_AES256GCM_KEYBYTES',
  18      'CRYPTO_AEAD_AES256GCM_NSECBYTES',
  19      'CRYPTO_AEAD_AES256GCM_NPUBBYTES',
  20      'CRYPTO_AEAD_AES256GCM_ABYTES',
  21      'CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES',
  22      'CRYPTO_AEAD_CHACHA20POLY1305_NSECBYTES',
  23      'CRYPTO_AEAD_CHACHA20POLY1305_NPUBBYTES',
  24      'CRYPTO_AEAD_CHACHA20POLY1305_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 $string1
 114       * @param string $string2
 115       * @return void
 116       * @throws SodiumException
 117       */
 118      function sodium_add(
 119          #[\SensitiveParameter]
 120          &$string1,
 121          #[\SensitiveParameter]
 122          $string2
 123      ) {
 124          ParagonIE_Sodium_Compat::add($string1, $string2);
 125      }
 126  }
 127  if (!is_callable('sodium_base642bin')) {
 128      /**
 129       * @see ParagonIE_Sodium_Compat::bin2base64()
 130       * @param string $string
 131       * @param int $variant
 132       * @param string $ignore
 133       * @return string
 134       * @throws SodiumException
 135       * @throws TypeError
 136       */
 137      function sodium_base642bin(
 138          #[\SensitiveParameter]
 139          $string,
 140          $variant,
 141          $ignore =''
 142      ) {
 143          return ParagonIE_Sodium_Compat::base642bin($string, $variant, $ignore);
 144      }
 145  }
 146  if (!is_callable('sodium_bin2base64')) {
 147      /**
 148       * @see ParagonIE_Sodium_Compat::bin2base64()
 149       * @param string $string
 150       * @param int $variant
 151       * @return string
 152       * @throws SodiumException
 153       * @throws TypeError
 154       */
 155      function sodium_bin2base64(
 156          #[\SensitiveParameter]
 157          $string,
 158          $variant
 159      ) {
 160          return ParagonIE_Sodium_Compat::bin2base64($string, $variant);
 161      }
 162  }
 163  if (!is_callable('sodium_bin2hex')) {
 164      /**
 165       * @see ParagonIE_Sodium_Compat::hex2bin()
 166       * @param string $string
 167       * @return string
 168       * @throws SodiumException
 169       * @throws TypeError
 170       */
 171      function sodium_bin2hex(
 172          #[\SensitiveParameter]
 173          $string
 174      ) {
 175          return ParagonIE_Sodium_Compat::bin2hex($string);
 176      }
 177  }
 178  if (!is_callable('sodium_compare')) {
 179      /**
 180       * @see ParagonIE_Sodium_Compat::compare()
 181       * @param string $string1
 182       * @param string $string2
 183       * @return int
 184       * @throws SodiumException
 185       * @throws TypeError
 186       */
 187      function sodium_compare(
 188          #[\SensitiveParameter]
 189          $string1,
 190          #[\SensitiveParameter]
 191          $string2
 192      ) {
 193          return ParagonIE_Sodium_Compat::compare($string1, $string2);
 194      }
 195  }
 196  if (!is_callable('sodium_crypto_aead_aes256gcm_decrypt')) {
 197      /**
 198       * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt()
 199       * @param string $ciphertext
 200       * @param string $additional_data
 201       * @param string $nonce
 202       * @param string $key
 203       * @return string|bool
 204       */
 205      function sodium_crypto_aead_aes256gcm_decrypt(
 206          $ciphertext,
 207          $additional_data,
 208          $nonce,
 209          #[\SensitiveParameter]
 210          $key
 211      ) {
 212          try {
 213              return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt(
 214                  $ciphertext,
 215                  $additional_data,
 216                  $nonce,
 217                  $key
 218              );
 219          } catch (Error $ex) {
 220              return false;
 221          } catch (Exception $ex) {
 222              if (($ex instanceof SodiumException) && ($ex->getMessage() === 'AES-256-GCM is not available')) {
 223                  throw $ex;
 224              }
 225              return false;
 226          }
 227      }
 228  }
 229  if (!is_callable('sodium_crypto_aead_aes256gcm_encrypt')) {
 230      /**
 231       * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt()
 232       * @param string $message
 233       * @param string $additional_data
 234       * @param string $nonce
 235       * @param string $key
 236       * @return string
 237       * @throws SodiumException
 238       * @throws TypeError
 239       */
 240      function sodium_crypto_aead_aes256gcm_encrypt(
 241          #[\SensitiveParameter]
 242          $message,
 243          $additional_data,
 244          $nonce,
 245          #[\SensitiveParameter]
 246          $key
 247      ) {
 248          return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt($message, $additional_data, $nonce, $key);
 249      }
 250  }
 251  if (!is_callable('sodium_crypto_aead_aes256gcm_is_available')) {
 252      /**
 253       * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_is_available()
 254       * @return bool
 255       */
 256      function sodium_crypto_aead_aes256gcm_is_available()
 257      {
 258          return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_is_available();
 259      }
 260  }
 261  if (!is_callable('sodium_crypto_aead_chacha20poly1305_decrypt')) {
 262      /**
 263       * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt()
 264       * @param string $ciphertext
 265       * @param string $additional_data
 266       * @param string $nonce
 267       * @param string $key
 268       * @return string|bool
 269       */
 270      function sodium_crypto_aead_chacha20poly1305_decrypt(
 271          $ciphertext,
 272          $additional_data,
 273          $nonce,
 274          #[\SensitiveParameter]
 275          $key
 276      ) {
 277          try {
 278              return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt(
 279                  $ciphertext,
 280                  $additional_data,
 281                  $nonce,
 282                  $key
 283              );
 284          } catch (Error $ex) {
 285              return false;
 286          } catch (Exception $ex) {
 287              return false;
 288          }
 289      }
 290  }
 291  if (!is_callable('sodium_crypto_aead_chacha20poly1305_encrypt')) {
 292      /**
 293       * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt()
 294       * @param string $message
 295       * @param string $additional_data
 296       * @param string $nonce
 297       * @param string $key
 298       * @return string
 299       * @throws SodiumException
 300       * @throws TypeError
 301       */
 302      function sodium_crypto_aead_chacha20poly1305_encrypt(
 303          #[\SensitiveParameter]
 304          $message,
 305          $additional_data,
 306          $nonce,
 307          #[\SensitiveParameter]
 308          $key
 309      ) {
 310          return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt(
 311              $message,
 312              $additional_data,
 313              $nonce,
 314              $key
 315          );
 316      }
 317  }
 318  if (!is_callable('sodium_crypto_aead_chacha20poly1305_keygen')) {
 319      /**
 320       * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_keygen()
 321       * @return string
 322       * @throws Exception
 323       */
 324      function sodium_crypto_aead_chacha20poly1305_keygen()
 325      {
 326          return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_keygen();
 327      }
 328  }
 329  if (!is_callable('sodium_crypto_aead_chacha20poly1305_ietf_decrypt')) {
 330      /**
 331       * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt()
 332       * @param string $message
 333       * @param string $additional_data
 334       * @param string $nonce
 335       * @param string $key
 336       * @return string|bool
 337       */
 338      function sodium_crypto_aead_chacha20poly1305_ietf_decrypt(
 339          $message,
 340          $additional_data,
 341          $nonce,
 342          #[\SensitiveParameter]
 343          $key
 344      ) {
 345          try {
 346              return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt(
 347                  $message,
 348                  $additional_data,
 349                  $nonce,
 350                  $key
 351              );
 352          } catch (Error $ex) {
 353              return false;
 354          } catch (Exception $ex) {
 355              return false;
 356          }
 357      }
 358  }
 359  if (!is_callable('sodium_crypto_aead_chacha20poly1305_ietf_encrypt')) {
 360      /**
 361       * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt()
 362       * @param string $message
 363       * @param string $additional_data
 364       * @param string $nonce
 365       * @param string $key
 366       * @return string
 367       * @throws SodiumException
 368       * @throws TypeError
 369       */
 370      function sodium_crypto_aead_chacha20poly1305_ietf_encrypt(
 371          #[\SensitiveParameter]
 372          $message,
 373          $additional_data,
 374          $nonce,
 375          #[\SensitiveParameter]
 376          $key
 377      ) {
 378          return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt(
 379              $message,
 380              $additional_data,
 381              $nonce,
 382              $key
 383          );
 384      }
 385  }
 386  if (!is_callable('sodium_crypto_aead_chacha20poly1305_ietf_keygen')) {
 387      /**
 388       * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_keygen()
 389       * @return string
 390       * @throws Exception
 391       */
 392      function sodium_crypto_aead_chacha20poly1305_ietf_keygen()
 393      {
 394          return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_keygen();
 395      }
 396  }
 397  if (!is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_decrypt')) {
 398      /**
 399       * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_decrypt()
 400       * @param string $ciphertext
 401       * @param string $additional_data
 402       * @param string $nonce
 403       * @param string $key
 404       * @return string|bool
 405       */
 406      function sodium_crypto_aead_xchacha20poly1305_ietf_decrypt(
 407          $ciphertext,
 408          $additional_data,
 409          $nonce,
 410          #[\SensitiveParameter]
 411          $key
 412      ) {
 413          try {
 414              return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_decrypt(
 415                  $ciphertext,
 416                  $additional_data,
 417                  $nonce,
 418                  $key,
 419                  true
 420              );
 421          } catch (Error $ex) {
 422              return false;
 423          } catch (Exception $ex) {
 424              return false;
 425          }
 426      }
 427  }
 428  if (!is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_encrypt')) {
 429      /**
 430       * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_encrypt()
 431       * @param string $message
 432       * @param string $additional_data
 433       * @param string $nonce
 434       * @param string $key
 435       * @return string
 436       * @throws SodiumException
 437       * @throws TypeError
 438       */
 439      function sodium_crypto_aead_xchacha20poly1305_ietf_encrypt(
 440          #[\SensitiveParameter]
 441          $message,
 442          $additional_data,
 443          $nonce,
 444          #[\SensitiveParameter]
 445          $key
 446      ) {
 447          return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_encrypt(
 448              $message,
 449              $additional_data,
 450              $nonce,
 451              $key,
 452              true
 453          );
 454      }
 455  }
 456  if (!is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_keygen')) {
 457      /**
 458       * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_keygen()
 459       * @return string
 460       * @throws Exception
 461       */
 462      function sodium_crypto_aead_xchacha20poly1305_ietf_keygen()
 463      {
 464          return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_keygen();
 465      }
 466  }
 467  if (!is_callable('sodium_crypto_auth')) {
 468      /**
 469       * @see ParagonIE_Sodium_Compat::crypto_auth()
 470       * @param string $message
 471       * @param string $key
 472       * @return string
 473       * @throws SodiumException
 474       * @throws TypeError
 475       */
 476      function sodium_crypto_auth(
 477          $message,
 478          #[\SensitiveParameter]
 479          $key
 480      ) {
 481          return ParagonIE_Sodium_Compat::crypto_auth($message, $key);
 482      }
 483  }
 484  if (!is_callable('sodium_crypto_auth_keygen')) {
 485      /**
 486       * @see ParagonIE_Sodium_Compat::crypto_auth_keygen()
 487       * @return string
 488       * @throws Exception
 489       */
 490      function sodium_crypto_auth_keygen()
 491      {
 492          return ParagonIE_Sodium_Compat::crypto_auth_keygen();
 493      }
 494  }
 495  if (!is_callable('sodium_crypto_auth_verify')) {
 496      /**
 497       * @see ParagonIE_Sodium_Compat::crypto_auth_verify()
 498       * @param string $mac
 499       * @param string $message
 500       * @param string $key
 501       * @return bool
 502       * @throws SodiumException
 503       * @throws TypeError
 504       */
 505      function sodium_crypto_auth_verify(
 506          $mac,
 507          $message,
 508          #[\SensitiveParameter]
 509          $key
 510      ) {
 511          return ParagonIE_Sodium_Compat::crypto_auth_verify($mac, $message, $key);
 512      }
 513  }
 514  if (!is_callable('sodium_crypto_box')) {
 515      /**
 516       * @see ParagonIE_Sodium_Compat::crypto_box()
 517       * @param string $message
 518       * @param string $nonce
 519       * @param string $key_pair
 520       * @return string
 521       * @throws SodiumException
 522       * @throws TypeError
 523       */
 524      function sodium_crypto_box(
 525          #[\SensitiveParameter]
 526          $message,
 527          $nonce,
 528          #[\SensitiveParameter]
 529          $key_pair
 530      ) {
 531          return ParagonIE_Sodium_Compat::crypto_box($message, $nonce, $key_pair);
 532      }
 533  }
 534  if (!is_callable('sodium_crypto_box_keypair')) {
 535      /**
 536       * @see ParagonIE_Sodium_Compat::crypto_box_keypair()
 537       * @return string
 538       * @throws SodiumException
 539       * @throws TypeError
 540       */
 541      function sodium_crypto_box_keypair()
 542      {
 543          return ParagonIE_Sodium_Compat::crypto_box_keypair();
 544      }
 545  }
 546  if (!is_callable('sodium_crypto_box_keypair_from_secretkey_and_publickey')) {
 547      /**
 548       * @see ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey()
 549       * @param string $secret_key
 550       * @param string $public_key
 551       * @return string
 552       * @throws SodiumException
 553       * @throws TypeError
 554       */
 555      function sodium_crypto_box_keypair_from_secretkey_and_publickey(
 556          #[\SensitiveParameter]
 557          $secret_key,
 558          $public_key
 559      ) {
 560          return ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey($secret_key, $public_key);
 561      }
 562  }
 563  if (!is_callable('sodium_crypto_box_open')) {
 564      /**
 565       * @see ParagonIE_Sodium_Compat::crypto_box_open()
 566       * @param string $ciphertext
 567       * @param string $nonce
 568       * @param string $key_pair
 569       * @return string|bool
 570       */
 571      function sodium_crypto_box_open(
 572          $ciphertext,
 573          $nonce,
 574          #[\SensitiveParameter]
 575          $key_pair
 576      ) {
 577          try {
 578              return ParagonIE_Sodium_Compat::crypto_box_open($ciphertext, $nonce, $key_pair);
 579          } catch (Error $ex) {
 580              return false;
 581          } catch (Exception $ex) {
 582              return false;
 583          }
 584      }
 585  }
 586  if (!is_callable('sodium_crypto_box_publickey')) {
 587      /**
 588       * @see ParagonIE_Sodium_Compat::crypto_box_publickey()
 589       * @param string $key_pair
 590       * @return string
 591       * @throws SodiumException
 592       * @throws TypeError
 593       */
 594      function sodium_crypto_box_publickey(
 595          #[\SensitiveParameter]
 596          $key_pair
 597      ) {
 598          return ParagonIE_Sodium_Compat::crypto_box_publickey($key_pair);
 599      }
 600  }
 601  if (!is_callable('sodium_crypto_box_publickey_from_secretkey')) {
 602      /**
 603       * @see ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey()
 604       * @param string $secret_key
 605       * @return string
 606       * @throws SodiumException
 607       * @throws TypeError
 608       */
 609      function sodium_crypto_box_publickey_from_secretkey(
 610          #[\SensitiveParameter]
 611          $secret_key
 612      ) {
 613          return ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey($secret_key);
 614      }
 615  }
 616  if (!is_callable('sodium_crypto_box_seal')) {
 617      /**
 618       * @see ParagonIE_Sodium_Compat::crypto_box_seal()
 619       * @param string $message
 620       * @param string $public_key
 621       * @return string
 622       * @throws SodiumException
 623       * @throws TypeError
 624       */
 625      function sodium_crypto_box_seal(
 626          #[\SensitiveParameter]
 627          $message,
 628          $public_key
 629      ) {
 630          return ParagonIE_Sodium_Compat::crypto_box_seal($message, $public_key);
 631      }
 632  }
 633  if (!is_callable('sodium_crypto_box_seal_open')) {
 634      /**
 635       * @see ParagonIE_Sodium_Compat::crypto_box_seal_open()
 636       * @param string $message
 637       * @param string $key_pair
 638       * @return string|bool
 639       * @throws SodiumException
 640       */
 641      function sodium_crypto_box_seal_open(
 642          $message,
 643          #[\SensitiveParameter]
 644          $key_pair
 645      ) {
 646          try {
 647              return ParagonIE_Sodium_Compat::crypto_box_seal_open($message, $key_pair);
 648          } catch (SodiumException $ex) {
 649              if ($ex->getMessage() === 'Argument 2 must be CRYPTO_BOX_KEYPAIRBYTES long.') {
 650                  throw $ex;
 651              }
 652              return false;
 653          }
 654      }
 655  }
 656  if (!is_callable('sodium_crypto_box_secretkey')) {
 657      /**
 658       * @see ParagonIE_Sodium_Compat::crypto_box_secretkey()
 659       * @param string $key_pair
 660       * @return string
 661       * @throws SodiumException
 662       * @throws TypeError
 663       */
 664      function sodium_crypto_box_secretkey(
 665          #[\SensitiveParameter]
 666          $key_pair
 667      ) {
 668          return ParagonIE_Sodium_Compat::crypto_box_secretkey($key_pair);
 669      }
 670  }
 671  if (!is_callable('sodium_crypto_box_seed_keypair')) {
 672      /**
 673       * @see ParagonIE_Sodium_Compat::crypto_box_seed_keypair()
 674       * @param string $seed
 675       * @return string
 676       * @throws SodiumException
 677       * @throws TypeError
 678       */
 679      function sodium_crypto_box_seed_keypair(
 680          #[\SensitiveParameter]
 681          $seed
 682      ) {
 683          return ParagonIE_Sodium_Compat::crypto_box_seed_keypair($seed);
 684      }
 685  }
 686  if (!is_callable('sodium_crypto_generichash')) {
 687      /**
 688       * @see ParagonIE_Sodium_Compat::crypto_generichash()
 689       * @param string $message
 690       * @param string|null $key
 691       * @param int $length
 692       * @return string
 693       * @throws SodiumException
 694       * @throws TypeError
 695       */
 696      function sodium_crypto_generichash(
 697          $message,
 698          #[\SensitiveParameter]
 699          $key = null,
 700          $length = 32
 701      ) {
 702          return ParagonIE_Sodium_Compat::crypto_generichash($message, $key, $length);
 703      }
 704  }
 705  if (!is_callable('sodium_crypto_generichash_final')) {
 706      /**
 707       * @see ParagonIE_Sodium_Compat::crypto_generichash_final()
 708       * @param string|null $state
 709       * @param int $outputLength
 710       * @return string
 711       * @throws SodiumException
 712       * @throws TypeError
 713       */
 714      function sodium_crypto_generichash_final(&$state, $outputLength = 32)
 715      {
 716          return ParagonIE_Sodium_Compat::crypto_generichash_final($state, $outputLength);
 717      }
 718  }
 719  if (!is_callable('sodium_crypto_generichash_init')) {
 720      /**
 721       * @see ParagonIE_Sodium_Compat::crypto_generichash_init()
 722       * @param string|null $key
 723       * @param int $length
 724       * @return string
 725       * @throws SodiumException
 726       * @throws TypeError
 727       */
 728      function sodium_crypto_generichash_init(
 729          #[\SensitiveParameter]
 730          $key = null,
 731          $length = 32
 732      ) {
 733          return ParagonIE_Sodium_Compat::crypto_generichash_init($key, $length);
 734      }
 735  }
 736  if (!is_callable('sodium_crypto_generichash_keygen')) {
 737      /**
 738       * @see ParagonIE_Sodium_Compat::crypto_generichash_keygen()
 739       * @return string
 740       * @throws Exception
 741       */
 742      function sodium_crypto_generichash_keygen()
 743      {
 744          return ParagonIE_Sodium_Compat::crypto_generichash_keygen();
 745      }
 746  }
 747  if (!is_callable('sodium_crypto_generichash_update')) {
 748      /**
 749       * @see ParagonIE_Sodium_Compat::crypto_generichash_update()
 750       * @param string|null $state
 751       * @param string $message
 752       * @return void
 753       * @throws SodiumException
 754       * @throws TypeError
 755       */
 756      function sodium_crypto_generichash_update(
 757          #[\SensitiveParameter]
 758          &$state,
 759          $message = ''
 760      ) {
 761          ParagonIE_Sodium_Compat::crypto_generichash_update($state, $message);
 762      }
 763  }
 764  if (!is_callable('sodium_crypto_kdf_keygen')) {
 765      /**
 766       * @see ParagonIE_Sodium_Compat::crypto_kdf_keygen()
 767       * @return string
 768       * @throws Exception
 769       */
 770      function sodium_crypto_kdf_keygen()
 771      {
 772          return ParagonIE_Sodium_Compat::crypto_kdf_keygen();
 773      }
 774  }
 775  if (!is_callable('sodium_crypto_kdf_derive_from_key')) {
 776      /**
 777       * @see ParagonIE_Sodium_Compat::crypto_kdf_derive_from_key()
 778       * @param int $subkey_length
 779       * @param int $subkey_id
 780       * @param string $context
 781       * @param string $key
 782       * @return string
 783       * @throws Exception
 784       */
 785      function sodium_crypto_kdf_derive_from_key(
 786          $subkey_length,
 787          $subkey_id,
 788          $context,
 789          #[\SensitiveParameter]
 790          $key
 791      ) {
 792          return ParagonIE_Sodium_Compat::crypto_kdf_derive_from_key(
 793              $subkey_length,
 794              $subkey_id,
 795              $context,
 796              $key
 797          );
 798      }
 799  }
 800  if (!is_callable('sodium_crypto_kx')) {
 801      /**
 802       * @see ParagonIE_Sodium_Compat::crypto_kx()
 803       * @param string $my_secret
 804       * @param string $their_public
 805       * @param string $client_public
 806       * @param string $server_public
 807       * @return string
 808       * @throws SodiumException
 809       * @throws TypeError
 810       */
 811      function sodium_crypto_kx(
 812          #[\SensitiveParameter]
 813          $my_secret,
 814          $their_public,
 815          $client_public,
 816          $server_public
 817      ) {
 818          return ParagonIE_Sodium_Compat::crypto_kx(
 819              $my_secret,
 820              $their_public,
 821              $client_public,
 822              $server_public
 823          );
 824      }
 825  }
 826  if (!is_callable('sodium_crypto_kx_seed_keypair')) {
 827      /**
 828       * @param string $seed
 829       * @return string
 830       * @throws Exception
 831       */
 832      function sodium_crypto_kx_seed_keypair(
 833          #[\SensitiveParameter]
 834          $seed
 835      ) {
 836          return ParagonIE_Sodium_Compat::crypto_kx_seed_keypair($seed);
 837      }
 838  }
 839  if (!is_callable('sodium_crypto_kx_keypair')) {
 840      /**
 841       * @return string
 842       * @throws Exception
 843       */
 844      function sodium_crypto_kx_keypair()
 845      {
 846          return ParagonIE_Sodium_Compat::crypto_kx_keypair();
 847      }
 848  }
 849  if (!is_callable('sodium_crypto_kx_client_session_keys')) {
 850      /**
 851       * @param string $client_key_pair
 852       * @param string $server_key
 853       * @return array{0: string, 1: string}
 854       * @throws SodiumException
 855       */
 856      function sodium_crypto_kx_client_session_keys(
 857          #[\SensitiveParameter]
 858          $client_key_pair,
 859          $server_key
 860      ) {
 861          return ParagonIE_Sodium_Compat::crypto_kx_client_session_keys($client_key_pair, $server_key);
 862      }
 863  }
 864  if (!is_callable('sodium_crypto_kx_server_session_keys')) {
 865      /**
 866       * @param string $server_key_pair
 867       * @param string $client_key
 868       * @return array{0: string, 1: string}
 869       * @throws SodiumException
 870       */
 871      function sodium_crypto_kx_server_session_keys(
 872          #[\SensitiveParameter]
 873          $server_key_pair,
 874          $client_key
 875      ) {
 876          return ParagonIE_Sodium_Compat::crypto_kx_server_session_keys($server_key_pair, $client_key);
 877      }
 878  }
 879  if (!is_callable('sodium_crypto_kx_secretkey')) {
 880      /**
 881       * @param string $key_pair
 882       * @return string
 883       * @throws Exception
 884       */
 885      function sodium_crypto_kx_secretkey(
 886          #[\SensitiveParameter]
 887          $key_pair
 888      ) {
 889          return ParagonIE_Sodium_Compat::crypto_kx_secretkey($key_pair);
 890      }
 891  }
 892  if (!is_callable('sodium_crypto_kx_publickey')) {
 893      /**
 894       * @param string $key_pair
 895       * @return string
 896       * @throws Exception
 897       */
 898      function sodium_crypto_kx_publickey(
 899          #[\SensitiveParameter]
 900          $key_pair
 901      ) {
 902          return ParagonIE_Sodium_Compat::crypto_kx_publickey($key_pair);
 903      }
 904  }
 905  if (!is_callable('sodium_crypto_pwhash')) {
 906      /**
 907       * @see ParagonIE_Sodium_Compat::crypto_pwhash()
 908       * @param int $length
 909       * @param string $passwd
 910       * @param string $salt
 911       * @param int $opslimit
 912       * @param int $memlimit
 913       * @param int|null $algo
 914       * @return string
 915       * @throws SodiumException
 916       * @throws TypeError
 917       */
 918      function sodium_crypto_pwhash(
 919          $length,
 920          #[\SensitiveParameter]
 921          $passwd,
 922          $salt,
 923          $opslimit,
 924          $memlimit,
 925          $algo = null
 926      ) {
 927          return ParagonIE_Sodium_Compat::crypto_pwhash($length, $passwd, $salt, $opslimit, $memlimit, $algo);
 928      }
 929  }
 930  if (!is_callable('sodium_crypto_pwhash_str')) {
 931      /**
 932       * @see ParagonIE_Sodium_Compat::crypto_pwhash_str()
 933       * @param string $passwd
 934       * @param int $opslimit
 935       * @param int $memlimit
 936       * @return string
 937       * @throws SodiumException
 938       * @throws TypeError
 939       */
 940      function sodium_crypto_pwhash_str(
 941          #[\SensitiveParameter]
 942          $passwd,
 943          $opslimit,
 944          $memlimit
 945      ) {
 946          return ParagonIE_Sodium_Compat::crypto_pwhash_str($passwd, $opslimit, $memlimit);
 947      }
 948  }
 949  if (!is_callable('sodium_crypto_pwhash_str_needs_rehash')) {
 950      /**
 951       * @see ParagonIE_Sodium_Compat::crypto_pwhash_str_needs_rehash()
 952       * @param string $hash
 953       * @param int $opslimit
 954       * @param int $memlimit
 955       * @return bool
 956       *
 957       * @throws SodiumException
 958       */
 959      function sodium_crypto_pwhash_str_needs_rehash(
 960          #[\SensitiveParameter]
 961          $hash,
 962          $opslimit,
 963          $memlimit
 964      ) {
 965          return ParagonIE_Sodium_Compat::crypto_pwhash_str_needs_rehash($hash, $opslimit, $memlimit);
 966      }
 967  }
 968  if (!is_callable('sodium_crypto_pwhash_str_verify')) {
 969      /**
 970       * @see ParagonIE_Sodium_Compat::crypto_pwhash_str_verify()
 971       * @param string $passwd
 972       * @param string $hash
 973       * @return bool
 974       * @throws SodiumException
 975       * @throws TypeError
 976       */
 977      function sodium_crypto_pwhash_str_verify(
 978          #[\SensitiveParameter]
 979          $passwd,
 980          #[\SensitiveParameter]
 981          $hash
 982      ) {
 983          return ParagonIE_Sodium_Compat::crypto_pwhash_str_verify($passwd, $hash);
 984      }
 985  }
 986  if (!is_callable('sodium_crypto_pwhash_scryptsalsa208sha256')) {
 987      /**
 988       * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256()
 989       * @param int $length
 990       * @param string $passwd
 991       * @param string $salt
 992       * @param int $opslimit
 993       * @param int $memlimit
 994       * @return string
 995       * @throws SodiumException
 996       * @throws TypeError
 997       */
 998      function sodium_crypto_pwhash_scryptsalsa208sha256(
 999          $length,
1000          #[\SensitiveParameter]
1001          $passwd,
1002          $salt,
1003          $opslimit,
1004          $memlimit
1005      ) {
1006          return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256(
1007              $length,
1008              $passwd,
1009              $salt,
1010              $opslimit,
1011              $memlimit
1012          );
1013      }
1014  }
1015  if (!is_callable('sodium_crypto_pwhash_scryptsalsa208sha256_str')) {
1016      /**
1017       * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str()
1018       * @param string $passwd
1019       * @param int $opslimit
1020       * @param int $memlimit
1021       * @return string
1022       * @throws SodiumException
1023       * @throws TypeError
1024       */
1025      function sodium_crypto_pwhash_scryptsalsa208sha256_str(
1026          #[\SensitiveParameter]
1027          $passwd,
1028          $opslimit,
1029          $memlimit
1030      ) {
1031          return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit);
1032      }
1033  }
1034  if (!is_callable('sodium_crypto_pwhash_scryptsalsa208sha256_str_verify')) {
1035      /**
1036       * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str_verify()
1037       * @param string $passwd
1038       * @param string $hash
1039       * @return bool
1040       * @throws SodiumException
1041       * @throws TypeError
1042       */
1043      function sodium_crypto_pwhash_scryptsalsa208sha256_str_verify(
1044          #[\SensitiveParameter]
1045          $passwd,
1046          #[\SensitiveParameter]
1047          $hash
1048      ) {
1049          return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash);
1050      }
1051  }
1052  if (!is_callable('sodium_crypto_scalarmult')) {
1053      /**
1054       * @see ParagonIE_Sodium_Compat::crypto_scalarmult()
1055       * @param string $n
1056       * @param string $p
1057       * @return string
1058       * @throws SodiumException
1059       * @throws TypeError
1060       */
1061      function sodium_crypto_scalarmult(
1062          #[\SensitiveParameter]
1063          $n,
1064          $p
1065      ) {
1066          return ParagonIE_Sodium_Compat::crypto_scalarmult($n, $p);
1067      }
1068  }
1069  if (!is_callable('sodium_crypto_scalarmult_base')) {
1070      /**
1071       * @see ParagonIE_Sodium_Compat::crypto_scalarmult_base()
1072       * @param string $n
1073       * @return string
1074       * @throws SodiumException
1075       * @throws TypeError
1076       */
1077      function sodium_crypto_scalarmult_base(
1078          #[\SensitiveParameter]
1079          $n
1080      ) {
1081          return ParagonIE_Sodium_Compat::crypto_scalarmult_base($n);
1082      }
1083  }
1084  if (!is_callable('sodium_crypto_secretbox')) {
1085      /**
1086       * @see ParagonIE_Sodium_Compat::crypto_secretbox()
1087       * @param string $message
1088       * @param string $nonce
1089       * @param string $key
1090       * @return string
1091       * @throws SodiumException
1092       * @throws TypeError
1093       */
1094      function sodium_crypto_secretbox(
1095          #[\SensitiveParameter]
1096          $message,
1097          $nonce,
1098          #[\SensitiveParameter]
1099          $key
1100      ) {
1101          return ParagonIE_Sodium_Compat::crypto_secretbox($message, $nonce, $key);
1102      }
1103  }
1104  if (!is_callable('sodium_crypto_secretbox_keygen')) {
1105      /**
1106       * @see ParagonIE_Sodium_Compat::crypto_secretbox_keygen()
1107       * @return string
1108       * @throws Exception
1109       */
1110      function sodium_crypto_secretbox_keygen()
1111      {
1112          return ParagonIE_Sodium_Compat::crypto_secretbox_keygen();
1113      }
1114  }
1115  if (!is_callable('sodium_crypto_secretbox_open')) {
1116      /**
1117       * @see ParagonIE_Sodium_Compat::crypto_secretbox_open()
1118       * @param string $ciphertext
1119       * @param string $nonce
1120       * @param string $key
1121       * @return string|bool
1122       */
1123      function sodium_crypto_secretbox_open(
1124          $ciphertext,
1125          $nonce,
1126          #[\SensitiveParameter]
1127          $key
1128      ) {
1129          try {
1130              return ParagonIE_Sodium_Compat::crypto_secretbox_open($ciphertext, $nonce, $key);
1131          } catch (Error $ex) {
1132              return false;
1133          } catch (Exception $ex) {
1134              return false;
1135          }
1136      }
1137  }
1138  if (!is_callable('sodium_crypto_secretstream_xchacha20poly1305_init_push')) {
1139      /**
1140       * @param string $key
1141       * @return array<int, string>
1142       * @throws SodiumException
1143       */
1144      function sodium_crypto_secretstream_xchacha20poly1305_init_push(
1145          #[\SensitiveParameter]
1146          $key
1147      ) {
1148          return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_init_push($key);
1149      }
1150  }
1151  if (!is_callable('sodium_crypto_secretstream_xchacha20poly1305_push')) {
1152      /**
1153       * @param string $state
1154       * @param string $message
1155       * @param string $additional_data
1156       * @param int $tag
1157       * @return string
1158       * @throws SodiumException
1159       */
1160      function sodium_crypto_secretstream_xchacha20poly1305_push(
1161          #[\SensitiveParameter]
1162          &$state,
1163          #[\SensitiveParameter]
1164          $message,
1165          $additional_data = '',
1166          $tag = 0
1167      ) {
1168          return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_push(
1169              $state,
1170              $message,
1171              $additional_data,
1172              $tag
1173          );
1174      }
1175  }
1176  if (!is_callable('sodium_crypto_secretstream_xchacha20poly1305_init_pull')) {
1177      /**
1178       * @param string $header
1179       * @param string $key
1180       * @return string
1181       * @throws Exception
1182       */
1183      function sodium_crypto_secretstream_xchacha20poly1305_init_pull(
1184          $header,
1185          #[\SensitiveParameter]
1186          $key
1187      ) {
1188          return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_init_pull($header, $key);
1189      }
1190  }
1191  if (!is_callable('sodium_crypto_secretstream_xchacha20poly1305_pull')) {
1192      /**
1193       * @param string $state
1194       * @param string $ciphertext
1195       * @param string $additional_data
1196       * @return bool|array{0: string, 1: int}
1197       * @throws SodiumException
1198       */
1199      function sodium_crypto_secretstream_xchacha20poly1305_pull(
1200          #[\SensitiveParameter]
1201          &$state,
1202          $ciphertext,
1203          $additional_data = ''
1204      ) {
1205          return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_pull(
1206              $state,
1207              $ciphertext,
1208              $additional_data
1209          );
1210      }
1211  }
1212  if (!is_callable('sodium_crypto_secretstream_xchacha20poly1305_rekey')) {
1213      /**
1214       * @param string $state
1215       * @return void
1216       * @throws SodiumException
1217       */
1218      function sodium_crypto_secretstream_xchacha20poly1305_rekey(
1219          #[\SensitiveParameter]
1220          &$state
1221      ) {
1222          ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_rekey($state);
1223      }
1224  }
1225  if (!is_callable('sodium_crypto_secretstream_xchacha20poly1305_keygen')) {
1226      /**
1227       * @return string
1228       * @throws Exception
1229       */
1230      function sodium_crypto_secretstream_xchacha20poly1305_keygen()
1231      {
1232          return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_keygen();
1233      }
1234  }
1235  if (!is_callable('sodium_crypto_shorthash')) {
1236      /**
1237       * @see ParagonIE_Sodium_Compat::crypto_shorthash()
1238       * @param string $message
1239       * @param string $key
1240       * @return string
1241       * @throws SodiumException
1242       * @throws TypeError
1243       */
1244      function sodium_crypto_shorthash(
1245          $message,
1246          #[\SensitiveParameter]
1247          $key = ''
1248      ) {
1249          return ParagonIE_Sodium_Compat::crypto_shorthash($message, $key);
1250      }
1251  }
1252  if (!is_callable('sodium_crypto_shorthash_keygen')) {
1253      /**
1254       * @see ParagonIE_Sodium_Compat::crypto_shorthash_keygen()
1255       * @return string
1256       * @throws Exception
1257       */
1258      function sodium_crypto_shorthash_keygen()
1259      {
1260          return ParagonIE_Sodium_Compat::crypto_shorthash_keygen();
1261      }
1262  }
1263  if (!is_callable('sodium_crypto_sign')) {
1264      /**
1265       * @see ParagonIE_Sodium_Compat::crypto_sign()
1266       * @param string $message
1267       * @param string $secret_key
1268       * @return string
1269       * @throws SodiumException
1270       * @throws TypeError
1271       */
1272      function sodium_crypto_sign(
1273          $message,
1274          #[\SensitiveParameter]
1275          $secret_key
1276      ) {
1277          return ParagonIE_Sodium_Compat::crypto_sign($message, $secret_key);
1278      }
1279  }
1280  if (!is_callable('sodium_crypto_sign_detached')) {
1281      /**
1282       * @see ParagonIE_Sodium_Compat::crypto_sign_detached()
1283       * @param string $message
1284       * @param string $secret_key
1285       * @return string
1286       * @throws SodiumException
1287       * @throws TypeError
1288       */
1289      function sodium_crypto_sign_detached(
1290          $message,
1291          #[\SensitiveParameter]
1292          $secret_key
1293      ) {
1294          return ParagonIE_Sodium_Compat::crypto_sign_detached($message, $secret_key);
1295      }
1296  }
1297  if (!is_callable('sodium_crypto_sign_keypair_from_secretkey_and_publickey')) {
1298      /**
1299       * @see ParagonIE_Sodium_Compat::crypto_sign_keypair_from_secretkey_and_publickey()
1300       * @param string $secret_key
1301       * @param string $public_key
1302       * @return string
1303       * @throws SodiumException
1304       * @throws TypeError
1305       */
1306      function sodium_crypto_sign_keypair_from_secretkey_and_publickey(
1307          #[\SensitiveParameter]
1308          $secret_key,
1309          $public_key
1310      ) {
1311          return ParagonIE_Sodium_Compat::crypto_sign_keypair_from_secretkey_and_publickey($secret_key, $public_key);
1312      }
1313  }
1314  if (!is_callable('sodium_crypto_sign_keypair')) {
1315      /**
1316       * @see ParagonIE_Sodium_Compat::crypto_sign_keypair()
1317       * @return string
1318       * @throws SodiumException
1319       * @throws TypeError
1320       */
1321      function sodium_crypto_sign_keypair()
1322      {
1323          return ParagonIE_Sodium_Compat::crypto_sign_keypair();
1324      }
1325  }
1326  if (!is_callable('sodium_crypto_sign_open')) {
1327      /**
1328       * @see ParagonIE_Sodium_Compat::crypto_sign_open()
1329       * @param string $signedMessage
1330       * @param string $public_key
1331       * @return string|bool
1332       */
1333      function sodium_crypto_sign_open($signedMessage, $public_key)
1334      {
1335          try {
1336              return ParagonIE_Sodium_Compat::crypto_sign_open($signedMessage, $public_key);
1337          } catch (Error $ex) {
1338              return false;
1339          } catch (Exception $ex) {
1340              return false;
1341          }
1342      }
1343  }
1344  if (!is_callable('sodium_crypto_sign_publickey')) {
1345      /**
1346       * @see ParagonIE_Sodium_Compat::crypto_sign_publickey()
1347       * @param string $key_pair
1348       * @return string
1349       * @throws SodiumException
1350       * @throws TypeError
1351       */
1352      function sodium_crypto_sign_publickey(
1353          #[\SensitiveParameter]
1354          $key_pair
1355      ) {
1356          return ParagonIE_Sodium_Compat::crypto_sign_publickey($key_pair);
1357      }
1358  }
1359  if (!is_callable('sodium_crypto_sign_publickey_from_secretkey')) {
1360      /**
1361       * @see ParagonIE_Sodium_Compat::crypto_sign_publickey_from_secretkey()
1362       * @param string $secret_key
1363       * @return string
1364       * @throws SodiumException
1365       * @throws TypeError
1366       */
1367      function sodium_crypto_sign_publickey_from_secretkey(
1368          #[\SensitiveParameter]
1369          $secret_key
1370      ) {
1371          return ParagonIE_Sodium_Compat::crypto_sign_publickey_from_secretkey($secret_key);
1372      }
1373  }
1374  if (!is_callable('sodium_crypto_sign_secretkey')) {
1375      /**
1376       * @see ParagonIE_Sodium_Compat::crypto_sign_secretkey()
1377       * @param string $key_pair
1378       * @return string
1379       * @throws SodiumException
1380       * @throws TypeError
1381       */
1382      function sodium_crypto_sign_secretkey(
1383          #[\SensitiveParameter]
1384          $key_pair
1385      ) {
1386          return ParagonIE_Sodium_Compat::crypto_sign_secretkey($key_pair);
1387      }
1388  }
1389  if (!is_callable('sodium_crypto_sign_seed_keypair')) {
1390      /**
1391       * @see ParagonIE_Sodium_Compat::crypto_sign_seed_keypair()
1392       * @param string $seed
1393       * @return string
1394       * @throws SodiumException
1395       * @throws TypeError
1396       */
1397      function sodium_crypto_sign_seed_keypair(
1398          #[\SensitiveParameter]
1399          $seed
1400      ) {
1401          return ParagonIE_Sodium_Compat::crypto_sign_seed_keypair($seed);
1402      }
1403  }
1404  if (!is_callable('sodium_crypto_sign_verify_detached')) {
1405      /**
1406       * @see ParagonIE_Sodium_Compat::crypto_sign_verify_detached()
1407       * @param string $signature
1408       * @param string $message
1409       * @param string $public_key
1410       * @return bool
1411       * @throws SodiumException
1412       * @throws TypeError
1413       */
1414      function sodium_crypto_sign_verify_detached($signature, $message, $public_key)
1415      {
1416          return ParagonIE_Sodium_Compat::crypto_sign_verify_detached($signature, $message, $public_key);
1417      }
1418  }
1419  if (!is_callable('sodium_crypto_sign_ed25519_pk_to_curve25519')) {
1420      /**
1421       * @see ParagonIE_Sodium_Compat::crypto_sign_ed25519_pk_to_curve25519()
1422       * @param string $public_key
1423       * @return string
1424       * @throws SodiumException
1425       * @throws TypeError
1426       */
1427      function sodium_crypto_sign_ed25519_pk_to_curve25519($public_key)
1428      {
1429          return ParagonIE_Sodium_Compat::crypto_sign_ed25519_pk_to_curve25519($public_key);
1430      }
1431  }
1432  if (!is_callable('sodium_crypto_sign_ed25519_sk_to_curve25519')) {
1433      /**
1434       * @see ParagonIE_Sodium_Compat::crypto_sign_ed25519_sk_to_curve25519()
1435       * @param string $secret_key
1436       * @return string
1437       * @throws SodiumException
1438       * @throws TypeError
1439       */
1440      function sodium_crypto_sign_ed25519_sk_to_curve25519(
1441          #[\SensitiveParameter]
1442          $secret_key
1443      ) {
1444          return ParagonIE_Sodium_Compat::crypto_sign_ed25519_sk_to_curve25519($secret_key);
1445      }
1446  }
1447  if (!is_callable('sodium_crypto_stream')) {
1448      /**
1449       * @see ParagonIE_Sodium_Compat::crypto_stream()
1450       * @param int $length
1451       * @param string $nonce
1452       * @param string $key
1453       * @return string
1454       * @throws SodiumException
1455       * @throws TypeError
1456       */
1457      function sodium_crypto_stream(
1458          $length,
1459          $nonce,
1460          #[\SensitiveParameter]
1461          $key
1462      ) {
1463          return ParagonIE_Sodium_Compat::crypto_stream($length, $nonce, $key);
1464      }
1465  }
1466  if (!is_callable('sodium_crypto_stream_keygen')) {
1467      /**
1468       * @see ParagonIE_Sodium_Compat::crypto_stream_keygen()
1469       * @return string
1470       * @throws Exception
1471       */
1472      function sodium_crypto_stream_keygen()
1473      {
1474          return ParagonIE_Sodium_Compat::crypto_stream_keygen();
1475      }
1476  }
1477  if (!is_callable('sodium_crypto_stream_xor')) {
1478      /**
1479       * @see ParagonIE_Sodium_Compat::crypto_stream_xor()
1480       * @param string $message
1481       * @param string $nonce
1482       * @param string $key
1483       * @return string
1484       * @throws SodiumException
1485       * @throws TypeError
1486       */
1487      function sodium_crypto_stream_xor(
1488          #[\SensitiveParameter]
1489          $message,
1490          $nonce,
1491          #[\SensitiveParameter]
1492          $key
1493      ) {
1494          return ParagonIE_Sodium_Compat::crypto_stream_xor($message, $nonce, $key);
1495      }
1496  }
1497  require_once dirname(__FILE__) . '/stream-xchacha20.php';
1498  if (!is_callable('sodium_hex2bin')) {
1499      /**
1500       * @see ParagonIE_Sodium_Compat::hex2bin()
1501       * @param string $string
1502       * @param string $ignore
1503       * @return string
1504       * @throws SodiumException
1505       * @throws TypeError
1506       */
1507      function sodium_hex2bin(
1508          #[\SensitiveParameter]
1509          $string,
1510          $ignore = ''
1511      ) {
1512          return ParagonIE_Sodium_Compat::hex2bin($string, $ignore);
1513      }
1514  }
1515  if (!is_callable('sodium_increment')) {
1516      /**
1517       * @see ParagonIE_Sodium_Compat::increment()
1518       * @param string $string
1519       * @return void
1520       * @throws SodiumException
1521       * @throws TypeError
1522       */
1523      function sodium_increment(
1524          #[\SensitiveParameter]
1525          &$string
1526      ) {
1527          ParagonIE_Sodium_Compat::increment($string);
1528      }
1529  }
1530  if (!is_callable('sodium_library_version_major')) {
1531      /**
1532       * @see ParagonIE_Sodium_Compat::library_version_major()
1533       * @return int
1534       */
1535      function sodium_library_version_major()
1536      {
1537          return ParagonIE_Sodium_Compat::library_version_major();
1538      }
1539  }
1540  if (!is_callable('sodium_library_version_minor')) {
1541      /**
1542       * @see ParagonIE_Sodium_Compat::library_version_minor()
1543       * @return int
1544       */
1545      function sodium_library_version_minor()
1546      {
1547          return ParagonIE_Sodium_Compat::library_version_minor();
1548      }
1549  }
1550  if (!is_callable('sodium_version_string')) {
1551      /**
1552       * @see ParagonIE_Sodium_Compat::version_string()
1553       * @return string
1554       */
1555      function sodium_version_string()
1556      {
1557          return ParagonIE_Sodium_Compat::version_string();
1558      }
1559  }
1560  if (!is_callable('sodium_memcmp')) {
1561      /**
1562       * @see ParagonIE_Sodium_Compat::memcmp()
1563       * @param string $string1
1564       * @param string $string2
1565       * @return int
1566       * @throws SodiumException
1567       * @throws TypeError
1568       */
1569      function sodium_memcmp(
1570          #[\SensitiveParameter]
1571          $string1,
1572          #[\SensitiveParameter]
1573          $string2
1574      ) {
1575          return ParagonIE_Sodium_Compat::memcmp($string1, $string2);
1576      }
1577  }
1578  if (!is_callable('sodium_memzero')) {
1579      /**
1580       * @see ParagonIE_Sodium_Compat::memzero()
1581       * @param string $string
1582       * @return void
1583       * @throws SodiumException
1584       * @throws TypeError
1585       *
1586       * @psalm-suppress ReferenceConstraintViolation
1587       */
1588      function sodium_memzero(
1589          #[\SensitiveParameter]
1590          &$string
1591      ) {
1592          ParagonIE_Sodium_Compat::memzero($string);
1593      }
1594  }
1595  if (!is_callable('sodium_pad')) {
1596      /**
1597       * @see ParagonIE_Sodium_Compat::pad()
1598       * @param string $unpadded
1599       * @param int $block_size
1600       * @return string
1601       * @throws SodiumException
1602       * @throws TypeError
1603       */
1604      function sodium_pad(
1605          #[\SensitiveParameter]
1606          $unpadded,
1607          $block_size
1608      ) {
1609          return ParagonIE_Sodium_Compat::pad($unpadded, $block_size, true);
1610      }
1611  }
1612  if (!is_callable('sodium_unpad')) {
1613      /**
1614       * @see ParagonIE_Sodium_Compat::pad()
1615       * @param string $padded
1616       * @param int $block_size
1617       * @return string
1618       * @throws SodiumException
1619       * @throws TypeError
1620       */
1621      function sodium_unpad(
1622          #[\SensitiveParameter]
1623          $padded,
1624          $block_size
1625      ) {
1626          return ParagonIE_Sodium_Compat::unpad($padded, $block_size, true);
1627      }
1628  }
1629  if (!is_callable('sodium_randombytes_buf')) {
1630      /**
1631       * @see ParagonIE_Sodium_Compat::randombytes_buf()
1632       * @param int $amount
1633       * @return string
1634       * @throws Exception
1635       */
1636      function sodium_randombytes_buf($amount)
1637      {
1638          return ParagonIE_Sodium_Compat::randombytes_buf($amount);
1639      }
1640  }
1641  
1642  if (!is_callable('sodium_randombytes_uniform')) {
1643      /**
1644       * @see ParagonIE_Sodium_Compat::randombytes_uniform()
1645       * @param int $upperLimit
1646       * @return int
1647       * @throws Exception
1648       */
1649      function sodium_randombytes_uniform($upperLimit)
1650      {
1651          return ParagonIE_Sodium_Compat::randombytes_uniform($upperLimit);
1652      }
1653  }
1654  
1655  if (!is_callable('sodium_randombytes_random16')) {
1656      /**
1657       * @see ParagonIE_Sodium_Compat::randombytes_random16()
1658       * @return int
1659       * @throws Exception
1660       */
1661      function sodium_randombytes_random16()
1662      {
1663          return ParagonIE_Sodium_Compat::randombytes_random16();
1664      }
1665  }