[ Index ]

PHP Cross Reference of WordPress Trunk (Updated Daily)

title

Body

[close]

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

   1  <?php
   2  
   3  /**
   4   * This file will monkey patch the pure-PHP implementation in place of the
   5   * PECL functions and constants, but only if they do not already exist.
   6   *
   7   * Thus, the functions or constants just proxy to the appropriate
   8   * ParagonIE_Sodium_Compat method or class constant, respectively.
   9   */
  10  foreach (array(
  11      'CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES',
  12      'CRYPTO_AEAD_CHACHA20POLY1305_NSECBYTES',
  13      'CRYPTO_AEAD_CHACHA20POLY1305_NPUBBYTES',
  14      'CRYPTO_AEAD_CHACHA20POLY1305_ABYTES',
  15      'CRYPTO_AEAD_AES256GCM_KEYBYTES',
  16      'CRYPTO_AEAD_AES256GCM_NSECBYTES',
  17      'CRYPTO_AEAD_AES256GCM_NPUBBYTES',
  18      'CRYPTO_AEAD_AES256GCM_ABYTES',
  19      'CRYPTO_AEAD_CHACHA20POLY1305_IETF_KEYBYTES',
  20      'CRYPTO_AEAD_CHACHA20POLY1305_IETF_NSECBYTES',
  21      'CRYPTO_AEAD_CHACHA20POLY1305_IETF_NPUBBYTES',
  22      'CRYPTO_AEAD_CHACHA20POLY1305_IETF_ABYTES',
  23      'CRYPTO_AUTH_BYTES',
  24      'CRYPTO_AUTH_KEYBYTES',
  25      'CRYPTO_BOX_SEALBYTES',
  26      'CRYPTO_BOX_SECRETKEYBYTES',
  27      'CRYPTO_BOX_PUBLICKEYBYTES',
  28      'CRYPTO_BOX_KEYPAIRBYTES',
  29      'CRYPTO_BOX_MACBYTES',
  30      'CRYPTO_BOX_NONCEBYTES',
  31      'CRYPTO_BOX_SEEDBYTES',
  32      'CRYPTO_KX_BYTES',
  33      'CRYPTO_KX_SEEDBYTES',
  34      'CRYPTO_KX_PUBLICKEYBYTES',
  35      'CRYPTO_KX_SECRETKEYBYTES',
  36      'CRYPTO_GENERICHASH_BYTES',
  37      'CRYPTO_GENERICHASH_BYTES_MIN',
  38      'CRYPTO_GENERICHASH_BYTES_MAX',
  39      'CRYPTO_GENERICHASH_KEYBYTES',
  40      'CRYPTO_GENERICHASH_KEYBYTES_MIN',
  41      'CRYPTO_GENERICHASH_KEYBYTES_MAX',
  42      'CRYPTO_PWHASH_SALTBYTES',
  43      'CRYPTO_PWHASH_STRPREFIX',
  44      'CRYPTO_PWHASH_ALG_ARGON2I13',
  45      'CRYPTO_PWHASH_ALG_ARGON2ID13',
  46      'CRYPTO_PWHASH_MEMLIMIT_INTERACTIVE',
  47      'CRYPTO_PWHASH_OPSLIMIT_INTERACTIVE',
  48      'CRYPTO_PWHASH_MEMLIMIT_MODERATE',
  49      'CRYPTO_PWHASH_OPSLIMIT_MODERATE',
  50      'CRYPTO_PWHASH_MEMLIMIT_SENSITIVE',
  51      'CRYPTO_PWHASH_OPSLIMIT_SENSITIVE',
  52      'CRYPTO_SCALARMULT_BYTES',
  53      'CRYPTO_SCALARMULT_SCALARBYTES',
  54      'CRYPTO_SHORTHASH_BYTES',
  55      'CRYPTO_SHORTHASH_KEYBYTES',
  56      'CRYPTO_SECRETBOX_KEYBYTES',
  57      'CRYPTO_SECRETBOX_MACBYTES',
  58      'CRYPTO_SECRETBOX_NONCEBYTES',
  59      'CRYPTO_SIGN_BYTES',
  60      'CRYPTO_SIGN_SEEDBYTES',
  61      'CRYPTO_SIGN_PUBLICKEYBYTES',
  62      'CRYPTO_SIGN_SECRETKEYBYTES',
  63      'CRYPTO_SIGN_KEYPAIRBYTES',
  64      'CRYPTO_STREAM_KEYBYTES',
  65      'CRYPTO_STREAM_NONCEBYTES',
  66      'LIBRARY_VERSION_MAJOR',
  67      'LIBRARY_VERSION_MINOR',
  68      'VERSION_STRING'
  69      ) as $constant
  70  ) {
  71      if (!defined("SODIUM_$constant")) {
  72          define("SODIUM_$constant", constant("ParagonIE_Sodium_Compat::$constant"));
  73      }
  74  }
  75  
  76  if (!is_callable('sodium_bin2hex')) {
  77      /**
  78       * @see ParagonIE_Sodium_Compat::hex2bin()
  79       * @param string $string
  80       * @return string
  81       * @throws SodiumException
  82       * @throws TypeError
  83       */
  84      function sodium_bin2hex($string)
  85      {
  86          return ParagonIE_Sodium_Compat::bin2hex($string);
  87      }
  88  }
  89  if (!is_callable('sodium_compare')) {
  90      /**
  91       * @see ParagonIE_Sodium_Compat::compare()
  92       * @param string $a
  93       * @param string $b
  94       * @return int
  95       * @throws SodiumException
  96       * @throws TypeError
  97       */
  98      function sodium_compare($a, $b)
  99      {
 100          return ParagonIE_Sodium_Compat::compare($a, $b);
 101      }
 102  }
 103  if (!is_callable('sodium_crypto_aead_aes256gcm_decrypt')) {
 104      /**
 105       * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt()
 106       * @param string $message
 107       * @param string $assocData
 108       * @param string $nonce
 109       * @param string $key
 110       * @return string|bool
 111       */
 112      function sodium_crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key)
 113      {
 114          try {
 115              return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key);
 116          } catch (Error $ex) {
 117              return false;
 118          } catch (Exception $ex) {
 119              return false;
 120          }
 121      }
 122  }
 123  if (!is_callable('sodium_crypto_aead_aes256gcm_encrypt')) {
 124      /**
 125       * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt()
 126       * @param string $message
 127       * @param string $assocData
 128       * @param string $nonce
 129       * @param string $key
 130       * @return string
 131       * @throws SodiumException
 132       * @throws TypeError
 133       */
 134      function sodium_crypto_aead_aes256gcm_encrypt($message, $assocData, $nonce, $key)
 135      {
 136          return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt($message, $assocData, $nonce, $key);
 137      }
 138  }
 139  if (!is_callable('sodium_crypto_aead_aes256gcm_is_available')) {
 140      /**
 141       * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_is_available()
 142       * @return bool
 143       */
 144      function sodium_crypto_aead_aes256gcm_is_available()
 145      {
 146          return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_is_available();
 147      }
 148  }
 149  if (!is_callable('sodium_crypto_aead_chacha20poly1305_decrypt')) {
 150      /**
 151       * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt()
 152       * @param string $message
 153       * @param string $assocData
 154       * @param string $nonce
 155       * @param string $key
 156       * @return string|bool
 157       */
 158      function sodium_crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key)
 159      {
 160          try {
 161              return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key);
 162          } catch (Error $ex) {
 163              return false;
 164          } catch (Exception $ex) {
 165              return false;
 166          }
 167      }
 168  }
 169  if (!is_callable('sodium_crypto_aead_chacha20poly1305_encrypt')) {
 170      /**
 171       * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt()
 172       * @param string $message
 173       * @param string $assocData
 174       * @param string $nonce
 175       * @param string $key
 176       * @return string
 177       * @throws SodiumException
 178       * @throws TypeError
 179       */
 180      function sodium_crypto_aead_chacha20poly1305_encrypt($message, $assocData, $nonce, $key)
 181      {
 182          return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt($message, $assocData, $nonce, $key);
 183      }
 184  }
 185  if (!is_callable('sodium_crypto_aead_chacha20poly1305_keygen')) {
 186      /**
 187       * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_keygen()
 188       * @return string
 189       */
 190      function sodium_crypto_aead_chacha20poly1305_keygen()
 191      {
 192          return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_keygen();
 193      }
 194  }
 195  if (!is_callable('sodium_crypto_aead_chacha20poly1305_ietf_decrypt')) {
 196      /**
 197       * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt()
 198       * @param string $message
 199       * @param string $assocData
 200       * @param string $nonce
 201       * @param string $key
 202       * @return string|bool
 203       */
 204      function sodium_crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key)
 205      {
 206          try {
 207              return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key);
 208          } catch (Error $ex) {
 209              return false;
 210          } catch (Exception $ex) {
 211              return false;
 212          }
 213      }
 214  }
 215  if (!is_callable('sodium_crypto_aead_chacha20poly1305_ietf_encrypt')) {
 216      /**
 217       * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt()
 218       * @param string $message
 219       * @param string $assocData
 220       * @param string $nonce
 221       * @param string $key
 222       * @return string
 223       * @throws SodiumException
 224       * @throws TypeError
 225       */
 226      function sodium_crypto_aead_chacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key)
 227      {
 228          return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key);
 229      }
 230  }
 231  if (!is_callable('sodium_crypto_aead_chacha20poly1305_ietf_keygen')) {
 232      /**
 233       * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_keygen()
 234       * @return string
 235       */
 236      function sodium_crypto_aead_chacha20poly1305_ietf_keygen()
 237      {
 238          return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_keygen();
 239      }
 240  }
 241  if (!is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_decrypt')) {
 242      /**
 243       * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_decrypt()
 244       * @param string $message
 245       * @param string $assocData
 246       * @param string $nonce
 247       * @param string $key
 248       * @return string|bool
 249       */
 250      function sodium_crypto_aead_xchacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key)
 251      {
 252          try {
 253              return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key, true);
 254          } catch (Error $ex) {
 255              return false;
 256          } catch (Exception $ex) {
 257              return false;
 258          }
 259      }
 260  }
 261  if (!is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_encrypt')) {
 262      /**
 263       * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_encrypt()
 264       * @param string $message
 265       * @param string $assocData
 266       * @param string $nonce
 267       * @param string $key
 268       * @return string
 269       * @throws SodiumException
 270       * @throws TypeError
 271       */
 272      function sodium_crypto_aead_xchacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key)
 273      {
 274          return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key, true);
 275      }
 276  }
 277  if (!is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_keygen')) {
 278      /**
 279       * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_keygen()
 280       * @return string
 281       */
 282      function sodium_crypto_aead_xchacha20poly1305_ietf_keygen()
 283      {
 284          return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_keygen();
 285      }
 286  }
 287  if (!is_callable('sodium_crypto_auth')) {
 288      /**
 289       * @see ParagonIE_Sodium_Compat::crypto_auth()
 290       * @param string $message
 291       * @param string $key
 292       * @return string
 293       * @throws SodiumException
 294       * @throws TypeError
 295       */
 296      function sodium_crypto_auth($message, $key)
 297      {
 298          return ParagonIE_Sodium_Compat::crypto_auth($message, $key);
 299      }
 300  }
 301  if (!is_callable('sodium_crypto_auth_keygen')) {
 302      /**
 303       * @see ParagonIE_Sodium_Compat::crypto_auth_keygen()
 304       * @return string
 305       */
 306      function sodium_crypto_auth_keygen()
 307      {
 308          return ParagonIE_Sodium_Compat::crypto_auth_keygen();
 309      }
 310  }
 311  if (!is_callable('sodium_crypto_auth_verify')) {
 312      /**
 313       * @see ParagonIE_Sodium_Compat::crypto_auth_verify()
 314       * @param string $mac
 315       * @param string $message
 316       * @param string $key
 317       * @return bool
 318       * @throws SodiumException
 319       * @throws TypeError
 320       */
 321      function sodium_crypto_auth_verify($mac, $message, $key)
 322      {
 323          return ParagonIE_Sodium_Compat::crypto_auth_verify($mac, $message, $key);
 324      }
 325  }
 326  if (!is_callable('sodium_crypto_box')) {
 327      /**
 328       * @see ParagonIE_Sodium_Compat::crypto_box()
 329       * @param string $message
 330       * @param string $nonce
 331       * @param string $kp
 332       * @return string
 333       * @throws SodiumException
 334       * @throws TypeError
 335       */
 336      function sodium_crypto_box($message, $nonce, $kp)
 337      {
 338          return ParagonIE_Sodium_Compat::crypto_box($message, $nonce, $kp);
 339      }
 340  }
 341  if (!is_callable('sodium_crypto_box_keypair')) {
 342      /**
 343       * @see ParagonIE_Sodium_Compat::crypto_box_keypair()
 344       * @return string
 345       * @throws SodiumException
 346       * @throws TypeError
 347       */
 348      function sodium_crypto_box_keypair()
 349      {
 350          return ParagonIE_Sodium_Compat::crypto_box_keypair();
 351      }
 352  }
 353  if (!is_callable('sodium_crypto_box_keypair_from_secretkey_and_publickey')) {
 354      /**
 355       * @see ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey()
 356       * @param string $sk
 357       * @param string $pk
 358       * @return string
 359       * @throws SodiumException
 360       * @throws TypeError
 361       */
 362      function sodium_crypto_box_keypair_from_secretkey_and_publickey($sk, $pk)
 363      {
 364          return ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey($sk, $pk);
 365      }
 366  }
 367  if (!is_callable('sodium_crypto_box_open')) {
 368      /**
 369       * @see ParagonIE_Sodium_Compat::crypto_box_open()
 370       * @param string $message
 371       * @param string $nonce
 372       * @param string $kp
 373       * @return string|bool
 374       */
 375      function sodium_crypto_box_open($message, $nonce, $kp)
 376      {
 377          try {
 378              return ParagonIE_Sodium_Compat::crypto_box_open($message, $nonce, $kp);
 379          } catch (Error $ex) {
 380              return false;
 381          } catch (Exception $ex) {
 382              return false;
 383          }
 384      }
 385  }
 386  if (!is_callable('sodium_crypto_box_publickey')) {
 387      /**
 388       * @see ParagonIE_Sodium_Compat::crypto_box_publickey()
 389       * @param string $keypair
 390       * @return string
 391       * @throws SodiumException
 392       * @throws TypeError
 393       */
 394      function sodium_crypto_box_publickey($keypair)
 395      {
 396          return ParagonIE_Sodium_Compat::crypto_box_publickey($keypair);
 397      }
 398  }
 399  if (!is_callable('sodium_crypto_box_publickey_from_secretkey')) {
 400      /**
 401       * @see ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey()
 402       * @param string $sk
 403       * @return string
 404       * @throws SodiumException
 405       * @throws TypeError
 406       */
 407      function sodium_crypto_box_publickey_from_secretkey($sk)
 408      {
 409          return ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey($sk);
 410      }
 411  }
 412  if (!is_callable('sodium_crypto_box_seal')) {
 413      /**
 414       * @see ParagonIE_Sodium_Compat::crypto_box_seal()
 415       * @param string $message
 416       * @param string $publicKey
 417       * @return string
 418       * @throws SodiumException
 419       * @throws TypeError
 420       */
 421      function sodium_crypto_box_seal($message, $publicKey)
 422      {
 423          return ParagonIE_Sodium_Compat::crypto_box_seal($message, $publicKey);
 424      }
 425  }
 426  if (!is_callable('sodium_crypto_box_seal_open')) {
 427      /**
 428       * @see ParagonIE_Sodium_Compat::crypto_box_seal_open()
 429       * @param string $message
 430       * @param string $kp
 431       * @return string|bool
 432       * @throws SodiumException
 433       */
 434      function sodium_crypto_box_seal_open($message, $kp)
 435      {
 436          try {
 437              return ParagonIE_Sodium_Compat::crypto_box_seal_open($message, $kp);
 438          } catch (SodiumException $ex) {
 439              if ($ex->getMessage() === 'Argument 2 must be CRYPTO_BOX_KEYPAIRBYTES long.') {
 440                  throw $ex;
 441              }
 442              return false;
 443          }
 444      }
 445  }
 446  if (!is_callable('sodium_crypto_box_secretkey')) {
 447      /**
 448       * @see ParagonIE_Sodium_Compat::crypto_box_secretkey()
 449       * @param string $keypair
 450       * @return string
 451       * @throws SodiumException
 452       * @throws TypeError
 453       */
 454      function sodium_crypto_box_secretkey($keypair)
 455      {
 456          return ParagonIE_Sodium_Compat::crypto_box_secretkey($keypair);
 457      }
 458  }
 459  if (!is_callable('sodium_crypto_box_seed_keypair')) {
 460      /**
 461       * @see ParagonIE_Sodium_Compat::crypto_box_seed_keypair()
 462       * @param string $seed
 463       * @return string
 464       * @throws SodiumException
 465       * @throws TypeError
 466       */
 467      function sodium_crypto_box_seed_keypair($seed)
 468      {
 469          return ParagonIE_Sodium_Compat::crypto_box_seed_keypair($seed);
 470      }
 471  }
 472  if (!is_callable('sodium_crypto_generichash')) {
 473      /**
 474       * @see ParagonIE_Sodium_Compat::crypto_generichash()
 475       * @param string $message
 476       * @param string|null $key
 477       * @param int $outLen
 478       * @return string
 479       * @throws SodiumException
 480       * @throws TypeError
 481       */
 482      function sodium_crypto_generichash($message, $key = null, $outLen = 32)
 483      {
 484          return ParagonIE_Sodium_Compat::crypto_generichash($message, $key, $outLen);
 485      }
 486  }
 487  if (!is_callable('sodium_crypto_generichash_final')) {
 488      /**
 489       * @see ParagonIE_Sodium_Compat::crypto_generichash_final()
 490       * @param string|null $ctx
 491       * @param int $outputLength
 492       * @return string
 493       * @throws SodiumException
 494       * @throws TypeError
 495       */
 496      function sodium_crypto_generichash_final(&$ctx, $outputLength = 32)
 497      {
 498          return ParagonIE_Sodium_Compat::crypto_generichash_final($ctx, $outputLength);
 499      }
 500  }
 501  if (!is_callable('sodium_crypto_generichash_init')) {
 502      /**
 503       * @see ParagonIE_Sodium_Compat::crypto_generichash_init()
 504       * @param string|null $key
 505       * @param int $outLen
 506       * @return string
 507       * @throws SodiumException
 508       * @throws TypeError
 509       */
 510      function sodium_crypto_generichash_init($key = null, $outLen = 32)
 511      {
 512          return ParagonIE_Sodium_Compat::crypto_generichash_init($key, $outLen);
 513      }
 514  }
 515  if (!is_callable('sodium_crypto_generichash_keygen')) {
 516      /**
 517       * @see ParagonIE_Sodium_Compat::crypto_generichash_keygen()
 518       * @return string
 519       */
 520      function sodium_crypto_generichash_keygen()
 521      {
 522          return ParagonIE_Sodium_Compat::crypto_generichash_keygen();
 523      }
 524  }
 525  if (!is_callable('sodium_crypto_generichash_update')) {
 526      /**
 527       * @see ParagonIE_Sodium_Compat::crypto_generichash_update()
 528       * @param string|null $ctx
 529       * @param string $message
 530       * @return void
 531       * @throws SodiumException
 532       * @throws TypeError
 533       */
 534      function sodium_crypto_generichash_update(&$ctx, $message = '')
 535      {
 536          ParagonIE_Sodium_Compat::crypto_generichash_update($ctx, $message);
 537      }
 538  }
 539  if (!is_callable('sodium_crypto_kx')) {
 540      /**
 541       * @see ParagonIE_Sodium_Compat::crypto_kx()
 542       * @param string $my_secret
 543       * @param string $their_public
 544       * @param string $client_public
 545       * @param string $server_public
 546       * @return string
 547       * @throws SodiumException
 548       * @throws TypeError
 549       */
 550      function sodium_crypto_kx($my_secret, $their_public, $client_public, $server_public)
 551      {
 552          return ParagonIE_Sodium_Compat::crypto_kx(
 553              $my_secret,
 554              $their_public,
 555              $client_public,
 556              $server_public
 557          );
 558      }
 559  }
 560  if (!is_callable('sodium_crypto_pwhash')) {
 561      /**
 562       * @see ParagonIE_Sodium_Compat::crypto_pwhash()
 563       * @param int $outlen
 564       * @param string $passwd
 565       * @param string $salt
 566       * @param int $opslimit
 567       * @param int $memlimit
 568       * @param int|null $algo
 569       * @return string
 570       * @throws SodiumException
 571       * @throws TypeError
 572       */
 573      function sodium_crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit, $algo = null)
 574      {
 575          return ParagonIE_Sodium_Compat::crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit, $algo);
 576      }
 577  }
 578  if (!is_callable('sodium_crypto_pwhash_str')) {
 579      /**
 580       * @see ParagonIE_Sodium_Compat::crypto_pwhash_str()
 581       * @param string $passwd
 582       * @param int $opslimit
 583       * @param int $memlimit
 584       * @return string
 585       * @throws SodiumException
 586       * @throws TypeError
 587       */
 588      function sodium_crypto_pwhash_str($passwd, $opslimit, $memlimit)
 589      {
 590          return ParagonIE_Sodium_Compat::crypto_pwhash_str($passwd, $opslimit, $memlimit);
 591      }
 592  }
 593  if (!is_callable('sodium_crypto_pwhash_str_verify')) {
 594      /**
 595       * @see ParagonIE_Sodium_Compat::crypto_pwhash_str_verify()
 596       * @param string $passwd
 597       * @param string $hash
 598       * @return bool
 599       * @throws SodiumException
 600       * @throws TypeError
 601       */
 602      function sodium_crypto_pwhash_str_verify($passwd, $hash)
 603      {
 604          return ParagonIE_Sodium_Compat::crypto_pwhash_str_verify($passwd, $hash);
 605      }
 606  }
 607  if (!is_callable('sodium_crypto_pwhash_scryptsalsa208sha256')) {
 608      /**
 609       * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256()
 610       * @param int $outlen
 611       * @param string $passwd
 612       * @param string $salt
 613       * @param int $opslimit
 614       * @param int $memlimit
 615       * @return string
 616       * @throws SodiumException
 617       * @throws TypeError
 618       */
 619      function sodium_crypto_pwhash_scryptsalsa208sha256($outlen, $passwd, $salt, $opslimit, $memlimit)
 620      {
 621          return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256($outlen, $passwd, $salt, $opslimit, $memlimit);
 622      }
 623  }
 624  if (!is_callable('sodium_crypto_pwhash_scryptsalsa208sha256_str')) {
 625      /**
 626       * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str()
 627       * @param string $passwd
 628       * @param int $opslimit
 629       * @param int $memlimit
 630       * @return string
 631       * @throws SodiumException
 632       * @throws TypeError
 633       */
 634      function sodium_crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit)
 635      {
 636          return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit);
 637      }
 638  }
 639  if (!is_callable('sodium_crypto_pwhash_scryptsalsa208sha256_str_verify')) {
 640      /**
 641       * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str_verify()
 642       * @param string $passwd
 643       * @param string $hash
 644       * @return bool
 645       * @throws SodiumException
 646       * @throws TypeError
 647       */
 648      function sodium_crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash)
 649      {
 650          return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash);
 651      }
 652  }
 653  if (!is_callable('sodium_crypto_scalarmult')) {
 654      /**
 655       * @see ParagonIE_Sodium_Compat::crypto_scalarmult()
 656       * @param string $n
 657       * @param string $p
 658       * @return string
 659       * @throws SodiumException
 660       * @throws TypeError
 661       */
 662      function sodium_crypto_scalarmult($n, $p)
 663      {
 664          return ParagonIE_Sodium_Compat::crypto_scalarmult($n, $p);
 665      }
 666  }
 667  if (!is_callable('sodium_crypto_scalarmult_base')) {
 668      /**
 669       * @see ParagonIE_Sodium_Compat::crypto_scalarmult_base()
 670       * @param string $n
 671       * @return string
 672       * @throws SodiumException
 673       * @throws TypeError
 674       */
 675      function sodium_crypto_scalarmult_base($n)
 676      {
 677          return ParagonIE_Sodium_Compat::crypto_scalarmult_base($n);
 678      }
 679  }
 680  if (!is_callable('sodium_crypto_secretbox')) {
 681      /**
 682       * @see ParagonIE_Sodium_Compat::crypto_secretbox()
 683       * @param string $message
 684       * @param string $nonce
 685       * @param string $key
 686       * @return string
 687       * @throws SodiumException
 688       * @throws TypeError
 689       */
 690      function sodium_crypto_secretbox($message, $nonce, $key)
 691      {
 692          return ParagonIE_Sodium_Compat::crypto_secretbox($message, $nonce, $key);
 693      }
 694  }
 695  if (!is_callable('sodium_crypto_secretbox_keygen')) {
 696      /**
 697       * @see ParagonIE_Sodium_Compat::crypto_secretbox_keygen()
 698       * @return string
 699       */
 700      function sodium_crypto_secretbox_keygen()
 701      {
 702          return ParagonIE_Sodium_Compat::crypto_secretbox_keygen();
 703      }
 704  }
 705  if (!is_callable('sodium_crypto_secretbox_open')) {
 706      /**
 707       * @see ParagonIE_Sodium_Compat::crypto_secretbox_open()
 708       * @param string $message
 709       * @param string $nonce
 710       * @param string $key
 711       * @return string|bool
 712       */
 713      function sodium_crypto_secretbox_open($message, $nonce, $key)
 714      {
 715          try {
 716              return ParagonIE_Sodium_Compat::crypto_secretbox_open($message, $nonce, $key);
 717          } catch (Error $ex) {
 718              return false;
 719          } catch (Exception $ex) {
 720              return false;
 721          }
 722      }
 723  }
 724  if (!is_callable('sodium_crypto_shorthash')) {
 725      /**
 726       * @see ParagonIE_Sodium_Compat::crypto_shorthash()
 727       * @param string $message
 728       * @param string $key
 729       * @return string
 730       * @throws SodiumException
 731       * @throws TypeError
 732       */
 733      function sodium_crypto_shorthash($message, $key = '')
 734      {
 735          return ParagonIE_Sodium_Compat::crypto_shorthash($message, $key);
 736      }
 737  }
 738  if (!is_callable('sodium_crypto_shorthash_keygen')) {
 739      /**
 740       * @see ParagonIE_Sodium_Compat::crypto_shorthash_keygen()
 741       * @return string
 742       */
 743      function sodium_crypto_shorthash_keygen()
 744      {
 745          return ParagonIE_Sodium_Compat::crypto_shorthash_keygen();
 746      }
 747  }
 748  if (!is_callable('sodium_crypto_sign')) {
 749      /**
 750       * @see ParagonIE_Sodium_Compat::crypto_sign()
 751       * @param string $message
 752       * @param string $sk
 753       * @return string
 754       * @throws SodiumException
 755       * @throws TypeError
 756       */
 757      function sodium_crypto_sign($message, $sk)
 758      {
 759          return ParagonIE_Sodium_Compat::crypto_sign($message, $sk);
 760      }
 761  }
 762  if (!is_callable('sodium_crypto_sign_detached')) {
 763      /**
 764       * @see ParagonIE_Sodium_Compat::crypto_sign_detached()
 765       * @param string $message
 766       * @param string $sk
 767       * @return string
 768       * @throws SodiumException
 769       * @throws TypeError
 770       */
 771      function sodium_crypto_sign_detached($message, $sk)
 772      {
 773          return ParagonIE_Sodium_Compat::crypto_sign_detached($message, $sk);
 774      }
 775  }
 776  if (!is_callable('sodium_crypto_sign_keypair')) {
 777      /**
 778       * @see ParagonIE_Sodium_Compat::crypto_sign_keypair()
 779       * @return string
 780       * @throws SodiumException
 781       * @throws TypeError
 782       */
 783      function sodium_crypto_sign_keypair()
 784      {
 785          return ParagonIE_Sodium_Compat::crypto_sign_keypair();
 786      }
 787  }
 788  if (!is_callable('sodium_crypto_sign_open')) {
 789      /**
 790       * @see ParagonIE_Sodium_Compat::crypto_sign_open()
 791       * @param string $signedMessage
 792       * @param string $pk
 793       * @return string|bool
 794       */
 795      function sodium_crypto_sign_open($signedMessage, $pk)
 796      {
 797          try {
 798              return ParagonIE_Sodium_Compat::crypto_sign_open($signedMessage, $pk);
 799          } catch (Error $ex) {
 800              return false;
 801          } catch (Exception $ex) {
 802              return false;
 803          }
 804      }
 805  }
 806  if (!is_callable('sodium_crypto_sign_publickey')) {
 807      /**
 808       * @see ParagonIE_Sodium_Compat::crypto_sign_publickey()
 809       * @param string $keypair
 810       * @return string
 811       * @throws SodiumException
 812       * @throws TypeError
 813       */
 814      function sodium_crypto_sign_publickey($keypair)
 815      {
 816          return ParagonIE_Sodium_Compat::crypto_sign_publickey($keypair);
 817      }
 818  }
 819  if (!is_callable('sodium_crypto_sign_publickey_from_secretkey')) {
 820      /**
 821       * @see ParagonIE_Sodium_Compat::crypto_sign_publickey_from_secretkey()
 822       * @param string $sk
 823       * @return string
 824       * @throws SodiumException
 825       * @throws TypeError
 826       */
 827      function sodium_crypto_sign_publickey_from_secretkey($sk)
 828      {
 829          return ParagonIE_Sodium_Compat::crypto_sign_publickey_from_secretkey($sk);
 830      }
 831  }
 832  if (!is_callable('sodium_crypto_sign_secretkey')) {
 833      /**
 834       * @see ParagonIE_Sodium_Compat::crypto_sign_secretkey()
 835       * @param string $keypair
 836       * @return string
 837       * @throws SodiumException
 838       * @throws TypeError
 839       */
 840      function sodium_crypto_sign_secretkey($keypair)
 841      {
 842          return ParagonIE_Sodium_Compat::crypto_sign_secretkey($keypair);
 843      }
 844  }
 845  if (!is_callable('sodium_crypto_sign_seed_keypair')) {
 846      /**
 847       * @see ParagonIE_Sodium_Compat::crypto_sign_seed_keypair()
 848       * @param string $seed
 849       * @return string
 850       * @throws SodiumException
 851       * @throws TypeError
 852       */
 853      function sodium_crypto_sign_seed_keypair($seed)
 854      {
 855          return ParagonIE_Sodium_Compat::crypto_sign_seed_keypair($seed);
 856      }
 857  }
 858  if (!is_callable('sodium_crypto_sign_verify_detached')) {
 859      /**
 860       * @see ParagonIE_Sodium_Compat::crypto_sign_verify_detached()
 861       * @param string $signature
 862       * @param string $message
 863       * @param string $pk
 864       * @return bool
 865       * @throws SodiumException
 866       * @throws TypeError
 867       */
 868      function sodium_crypto_sign_verify_detached($signature, $message, $pk)
 869      {
 870          return ParagonIE_Sodium_Compat::crypto_sign_verify_detached($signature, $message, $pk);
 871      }
 872  }
 873  if (!is_callable('sodium_crypto_sign_ed25519_pk_to_curve25519')) {
 874      /**
 875       * @see ParagonIE_Sodium_Compat::crypto_sign_ed25519_pk_to_curve25519()
 876       * @param string $pk
 877       * @return string
 878       * @throws SodiumException
 879       * @throws TypeError
 880       */
 881      function sodium_crypto_sign_ed25519_pk_to_curve25519($pk)
 882      {
 883          return ParagonIE_Sodium_Compat::crypto_sign_ed25519_pk_to_curve25519($pk);
 884      }
 885  }
 886  if (!is_callable('sodium_crypto_sign_ed25519_sk_to_curve25519')) {
 887      /**
 888       * @see ParagonIE_Sodium_Compat::crypto_sign_ed25519_sk_to_curve25519()
 889       * @param string $sk
 890       * @return string
 891       * @throws SodiumException
 892       * @throws TypeError
 893       */
 894      function sodium_crypto_sign_ed25519_sk_to_curve25519($sk)
 895      {
 896          return ParagonIE_Sodium_Compat::crypto_sign_ed25519_sk_to_curve25519($sk);
 897      }
 898  }
 899  if (!is_callable('sodium_crypto_stream')) {
 900      /**
 901       * @see ParagonIE_Sodium_Compat::crypto_stream()
 902       * @param int $len
 903       * @param string $nonce
 904       * @param string $key
 905       * @return string
 906       * @throws SodiumException
 907       * @throws TypeError
 908       */
 909      function sodium_crypto_stream($len, $nonce, $key)
 910      {
 911          return ParagonIE_Sodium_Compat::crypto_stream($len, $nonce, $key);
 912      }
 913  }
 914  if (!is_callable('sodium_crypto_stream_keygen')) {
 915      /**
 916       * @see ParagonIE_Sodium_Compat::crypto_stream_keygen()
 917       * @return string
 918       */
 919      function sodium_crypto_stream_keygen()
 920      {
 921          return ParagonIE_Sodium_Compat::crypto_stream_keygen();
 922      }
 923  }
 924  if (!is_callable('sodium_crypto_stream_xor')) {
 925      /**
 926       * @see ParagonIE_Sodium_Compat::crypto_stream_xor()
 927       * @param string $message
 928       * @param string $nonce
 929       * @param string $key
 930       * @return string
 931       * @throws SodiumException
 932       * @throws TypeError
 933       */
 934      function sodium_crypto_stream_xor($message, $nonce, $key)
 935      {
 936          return ParagonIE_Sodium_Compat::crypto_stream_xor($message, $nonce, $key);
 937      }
 938  }
 939  if (!is_callable('sodium_hex2bin')) {
 940      /**
 941       * @see ParagonIE_Sodium_Compat::hex2bin()
 942       * @param string $string
 943       * @return string
 944       * @throws SodiumException
 945       * @throws TypeError
 946       */
 947      function sodium_hex2bin($string)
 948      {
 949          return ParagonIE_Sodium_Compat::hex2bin($string);
 950      }
 951  }
 952  if (!is_callable('sodium_increment')) {
 953      /**
 954       * @see ParagonIE_Sodium_Compat::increment()
 955       * @param string $string
 956       * @return void
 957       * @throws SodiumException
 958       * @throws TypeError
 959       */
 960      function sodium_increment(&$string)
 961      {
 962          ParagonIE_Sodium_Compat::increment($string);
 963      }
 964  }
 965  if (!is_callable('sodium_library_version_major')) {
 966      /**
 967       * @see ParagonIE_Sodium_Compat::library_version_major()
 968       * @return int
 969       */
 970      function sodium_library_version_major()
 971      {
 972          return ParagonIE_Sodium_Compat::library_version_major();
 973      }
 974  }
 975  if (!is_callable('sodium_library_version_minor')) {
 976      /**
 977       * @see ParagonIE_Sodium_Compat::library_version_minor()
 978       * @return int
 979       */
 980      function sodium_library_version_minor()
 981      {
 982          return ParagonIE_Sodium_Compat::library_version_minor();
 983      }
 984  }
 985  if (!is_callable('sodium_version_string')) {
 986      /**
 987       * @see ParagonIE_Sodium_Compat::version_string()
 988       * @return string
 989       */
 990      function sodium_version_string()
 991      {
 992          return ParagonIE_Sodium_Compat::version_string();
 993      }
 994  }
 995  if (!is_callable('sodium_memcmp')) {
 996      /**
 997       * @see ParagonIE_Sodium_Compat::memcmp()
 998       * @param string $a
 999       * @param string $b
1000       * @return int
1001       * @throws SodiumException
1002       * @throws TypeError
1003       */
1004      function sodium_memcmp($a, $b)
1005      {
1006          return ParagonIE_Sodium_Compat::memcmp($a, $b);
1007      }
1008  }
1009  if (!is_callable('sodium_memzero')) {
1010      /**
1011       * @see ParagonIE_Sodium_Compat::memzero()
1012       * @param string $str
1013       * @return void
1014       * @throws SodiumException
1015       * @throws TypeError
1016       */
1017      function sodium_memzero(&$str)
1018      {
1019          ParagonIE_Sodium_Compat::memzero($str);
1020      }
1021  }
1022  if (!is_callable('sodium_randombytes_buf')) {
1023      /**
1024       * @see ParagonIE_Sodium_Compat::randombytes_buf()
1025       * @param int $amount
1026       * @return string
1027       * @throws Exception
1028       */
1029      function sodium_randombytes_buf($amount)
1030      {
1031          return ParagonIE_Sodium_Compat::randombytes_buf($amount);
1032      }
1033  }
1034  
1035  if (!is_callable('sodium_randombytes_uniform')) {
1036      /**
1037       * @see ParagonIE_Sodium_Compat::randombytes_uniform()
1038       * @param int $upperLimit
1039       * @return int
1040       * @throws Exception
1041       */
1042      function sodium_randombytes_uniform($upperLimit)
1043      {
1044          return ParagonIE_Sodium_Compat::randombytes_uniform($upperLimit);
1045      }
1046  }
1047  
1048  if (!is_callable('sodium_randombytes_random16')) {
1049      /**
1050       * @see ParagonIE_Sodium_Compat::randombytes_random16()
1051       * @return int
1052       */
1053      function sodium_randombytes_random16()
1054      {
1055          return ParagonIE_Sodium_Compat::randombytes_random16();
1056      }
1057  }


Generated: Fri Oct 25 08:20:01 2019 Cross-referenced by PHPXref 0.7