[ Index ]

PHP Cross Reference of WordPress

title

Body

[close]

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

   1  <?php
   2  namespace Sodium;
   3  
   4  use ParagonIE_Sodium_Compat;
   5  
   6  /**
   7   * This file will monkey patch the pure-PHP implementation in place of the
   8   * PECL functions, but only if they do not already exist.
   9   *
  10   * Thus, the functions just proxy to the appropriate ParagonIE_Sodium_Compat
  11   * method.
  12   */
  13  if (!is_callable('\\Sodium\\bin2hex')) {
  14      /**
  15       * @see ParagonIE_Sodium_Compat::bin2hex()
  16       * @param string $string
  17       * @return string
  18       * @throws \SodiumException
  19       * @throws \TypeError
  20       */
  21      function bin2hex($string)
  22      {
  23          return ParagonIE_Sodium_Compat::bin2hex($string);
  24      }
  25  }
  26  if (!is_callable('\\Sodium\\compare')) {
  27      /**
  28       * @see ParagonIE_Sodium_Compat::compare()
  29       * @param string $a
  30       * @param string $b
  31       * @return int
  32       * @throws \SodiumException
  33       * @throws \TypeError
  34       */
  35      function compare($a, $b)
  36      {
  37          return ParagonIE_Sodium_Compat::compare($a, $b);
  38      }
  39  }
  40  if (!is_callable('\\Sodium\\crypto_aead_aes256gcm_decrypt')) {
  41      /**
  42       * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt()
  43       * @param string $message
  44       * @param string $assocData
  45       * @param string $nonce
  46       * @param string $key
  47       * @return string|bool
  48       */
  49      function crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key)
  50      {
  51          try {
  52              return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key);
  53          } catch (\TypeError $ex) {
  54              return false;
  55          } catch (\SodiumException $ex) {
  56              return false;
  57          }
  58      }
  59  }
  60  if (!is_callable('\\Sodium\\crypto_aead_aes256gcm_encrypt')) {
  61      /**
  62       * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt()
  63       * @param string $message
  64       * @param string $assocData
  65       * @param string $nonce
  66       * @param string $key
  67       * @return string
  68       * @throws \SodiumException
  69       * @throws \TypeError
  70       */
  71      function crypto_aead_aes256gcm_encrypt($message, $assocData, $nonce, $key)
  72      {
  73          return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt($message, $assocData, $nonce, $key);
  74      }
  75  }
  76  if (!is_callable('\\Sodium\\crypto_aead_aes256gcm_is_available')) {
  77      /**
  78       * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_is_available()
  79       * @return bool
  80       */
  81      function crypto_aead_aes256gcm_is_available()
  82      {
  83          return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_is_available();
  84      }
  85  }
  86  if (!is_callable('\\Sodium\\crypto_aead_chacha20poly1305_decrypt')) {
  87      /**
  88       * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt()
  89       * @param string $message
  90       * @param string $assocData
  91       * @param string $nonce
  92       * @param string $key
  93       * @return string|bool
  94       */
  95      function crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key)
  96      {
  97          try {
  98              return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key);
  99          } catch (\TypeError $ex) {
 100              return false;
 101          } catch (\SodiumException $ex) {
 102              return false;
 103          }
 104      }
 105  }
 106  if (!is_callable('\\Sodium\\crypto_aead_chacha20poly1305_encrypt')) {
 107      /**
 108       * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt()
 109       * @param string $message
 110       * @param string $assocData
 111       * @param string $nonce
 112       * @param string $key
 113       * @return string
 114       * @throws \SodiumException
 115       * @throws \TypeError
 116       */
 117      function crypto_aead_chacha20poly1305_encrypt($message, $assocData, $nonce, $key)
 118      {
 119          return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt($message, $assocData, $nonce, $key);
 120      }
 121  }
 122  if (!is_callable('\\Sodium\\crypto_aead_chacha20poly1305_ietf_decrypt')) {
 123      /**
 124       * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt()
 125       * @param string $message
 126       * @param string $assocData
 127       * @param string $nonce
 128       * @param string $key
 129       * @return string|bool
 130       */
 131      function crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key)
 132      {
 133          try {
 134              return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key);
 135          } catch (\TypeError $ex) {
 136              return false;
 137          } catch (\SodiumException $ex) {
 138              return false;
 139          }
 140      }
 141  }
 142  if (!is_callable('\\Sodium\\crypto_aead_chacha20poly1305_ietf_encrypt')) {
 143      /**
 144       * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt()
 145       * @param string $message
 146       * @param string $assocData
 147       * @param string $nonce
 148       * @param string $key
 149       * @return string
 150       * @throws \SodiumException
 151       * @throws \TypeError
 152       */
 153      function crypto_aead_chacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key)
 154      {
 155          return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key);
 156      }
 157  }
 158  if (!is_callable('\\Sodium\\crypto_auth')) {
 159      /**
 160       * @see ParagonIE_Sodium_Compat::crypto_auth()
 161       * @param string $message
 162       * @param string $key
 163       * @return string
 164       * @throws \SodiumException
 165       * @throws \TypeError
 166       */
 167      function crypto_auth($message, $key)
 168      {
 169          return ParagonIE_Sodium_Compat::crypto_auth($message, $key);
 170      }
 171  }
 172  if (!is_callable('\\Sodium\\crypto_auth_verify')) {
 173      /**
 174       * @see ParagonIE_Sodium_Compat::crypto_auth_verify()
 175       * @param string $mac
 176       * @param string $message
 177       * @param string $key
 178       * @return bool
 179       * @throws \SodiumException
 180       * @throws \TypeError
 181       */
 182      function crypto_auth_verify($mac, $message, $key)
 183      {
 184          return ParagonIE_Sodium_Compat::crypto_auth_verify($mac, $message, $key);
 185      }
 186  }
 187  if (!is_callable('\\Sodium\\crypto_box')) {
 188      /**
 189       * @see ParagonIE_Sodium_Compat::crypto_box()
 190       * @param string $message
 191       * @param string $nonce
 192       * @param string $kp
 193       * @return string
 194       * @throws \SodiumException
 195       * @throws \TypeError
 196       */
 197      function crypto_box($message, $nonce, $kp)
 198      {
 199          return ParagonIE_Sodium_Compat::crypto_box($message, $nonce, $kp);
 200      }
 201  }
 202  if (!is_callable('\\Sodium\\crypto_box_keypair')) {
 203      /**
 204       * @see ParagonIE_Sodium_Compat::crypto_box_keypair()
 205       * @return string
 206       * @throws \SodiumException
 207       * @throws \TypeError
 208       */
 209      function crypto_box_keypair()
 210      {
 211          return ParagonIE_Sodium_Compat::crypto_box_keypair();
 212      }
 213  }
 214  if (!is_callable('\\Sodium\\crypto_box_keypair_from_secretkey_and_publickey')) {
 215      /**
 216       * @see ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey()
 217       * @param string $sk
 218       * @param string $pk
 219       * @return string
 220       * @throws \SodiumException
 221       * @throws \TypeError
 222       */
 223      function crypto_box_keypair_from_secretkey_and_publickey($sk, $pk)
 224      {
 225          return ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey($sk, $pk);
 226      }
 227  }
 228  if (!is_callable('\\Sodium\\crypto_box_open')) {
 229      /**
 230       * @see ParagonIE_Sodium_Compat::crypto_box_open()
 231       * @param string $message
 232       * @param string $nonce
 233       * @param string $kp
 234       * @return string|bool
 235       */
 236      function crypto_box_open($message, $nonce, $kp)
 237      {
 238          try {
 239              return ParagonIE_Sodium_Compat::crypto_box_open($message, $nonce, $kp);
 240          } catch (\TypeError $ex) {
 241              return false;
 242          } catch (\SodiumException $ex) {
 243              return false;
 244          }
 245      }
 246  }
 247  if (!is_callable('\\Sodium\\crypto_box_publickey')) {
 248      /**
 249       * @see ParagonIE_Sodium_Compat::crypto_box_publickey()
 250       * @param string $keypair
 251       * @return string
 252       * @throws \SodiumException
 253       * @throws \TypeError
 254       */
 255      function crypto_box_publickey($keypair)
 256      {
 257          return ParagonIE_Sodium_Compat::crypto_box_publickey($keypair);
 258      }
 259  }
 260  if (!is_callable('\\Sodium\\crypto_box_publickey_from_secretkey')) {
 261      /**
 262       * @see ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey()
 263       * @param string $sk
 264       * @return string
 265       * @throws \SodiumException
 266       * @throws \TypeError
 267       */
 268      function crypto_box_publickey_from_secretkey($sk)
 269      {
 270          return ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey($sk);
 271      }
 272  }
 273  if (!is_callable('\\Sodium\\crypto_box_seal')) {
 274      /**
 275       * @see ParagonIE_Sodium_Compat::crypto_box_seal_open()
 276       * @param string $message
 277       * @param string $publicKey
 278       * @return string
 279       * @throws \SodiumException
 280       * @throws \TypeError
 281       */
 282      function crypto_box_seal($message, $publicKey)
 283      {
 284          return ParagonIE_Sodium_Compat::crypto_box_seal($message, $publicKey);
 285      }
 286  }
 287  if (!is_callable('\\Sodium\\crypto_box_seal_open')) {
 288      /**
 289       * @see ParagonIE_Sodium_Compat::crypto_box_seal_open()
 290       * @param string $message
 291       * @param string $kp
 292       * @return string|bool
 293       */
 294      function crypto_box_seal_open($message, $kp)
 295      {
 296          try {
 297              return ParagonIE_Sodium_Compat::crypto_box_seal_open($message, $kp);
 298          } catch (\TypeError $ex) {
 299              return false;
 300          } catch (\SodiumException $ex) {
 301              return false;
 302          }
 303      }
 304  }
 305  if (!is_callable('\\Sodium\\crypto_box_secretkey')) {
 306      /**
 307       * @see ParagonIE_Sodium_Compat::crypto_box_secretkey()
 308       * @param string $keypair
 309       * @return string
 310       * @throws \SodiumException
 311       * @throws \TypeError
 312       */
 313      function crypto_box_secretkey($keypair)
 314      {
 315          return ParagonIE_Sodium_Compat::crypto_box_secretkey($keypair);
 316      }
 317  }
 318  if (!is_callable('\\Sodium\\crypto_generichash')) {
 319      /**
 320       * @see ParagonIE_Sodium_Compat::crypto_generichash()
 321       * @param string $message
 322       * @param string|null $key
 323       * @param int $outLen
 324       * @return string
 325       * @throws \SodiumException
 326       * @throws \TypeError
 327       */
 328      function crypto_generichash($message, $key = null, $outLen = 32)
 329      {
 330          return ParagonIE_Sodium_Compat::crypto_generichash($message, $key, $outLen);
 331      }
 332  }
 333  if (!is_callable('\\Sodium\\crypto_generichash_final')) {
 334      /**
 335       * @see ParagonIE_Sodium_Compat::crypto_generichash_final()
 336       * @param string|null $ctx
 337       * @param int $outputLength
 338       * @return string
 339       * @throws \SodiumException
 340       * @throws \TypeError
 341       */
 342      function crypto_generichash_final(&$ctx, $outputLength = 32)
 343      {
 344          return ParagonIE_Sodium_Compat::crypto_generichash_final($ctx, $outputLength);
 345      }
 346  }
 347  if (!is_callable('\\Sodium\\crypto_generichash_init')) {
 348      /**
 349       * @see ParagonIE_Sodium_Compat::crypto_generichash_init()
 350       * @param string|null $key
 351       * @param int $outLen
 352       * @return string
 353       * @throws \SodiumException
 354       * @throws \TypeError
 355       */
 356      function crypto_generichash_init($key = null, $outLen = 32)
 357      {
 358          return ParagonIE_Sodium_Compat::crypto_generichash_init($key, $outLen);
 359      }
 360  }
 361  if (!is_callable('\\Sodium\\crypto_generichash_update')) {
 362      /**
 363       * @see ParagonIE_Sodium_Compat::crypto_generichash_update()
 364       * @param string|null $ctx
 365       * @param string $message
 366       * @return void
 367       * @throws \SodiumException
 368       * @throws \TypeError
 369       */
 370      function crypto_generichash_update(&$ctx, $message = '')
 371      {
 372          ParagonIE_Sodium_Compat::crypto_generichash_update($ctx, $message);
 373      }
 374  }
 375  if (!is_callable('\\Sodium\\crypto_kx')) {
 376      /**
 377       * @see ParagonIE_Sodium_Compat::crypto_kx()
 378       * @param string $my_secret
 379       * @param string $their_public
 380       * @param string $client_public
 381       * @param string $server_public
 382       * @return string
 383       * @throws \SodiumException
 384       * @throws \TypeError
 385       */
 386      function crypto_kx($my_secret, $their_public, $client_public, $server_public)
 387      {
 388          return ParagonIE_Sodium_Compat::crypto_kx(
 389              $my_secret,
 390              $their_public,
 391              $client_public,
 392              $server_public
 393          );
 394      }
 395  }
 396  if (!is_callable('\\Sodium\\crypto_pwhash')) {
 397      /**
 398       * @see ParagonIE_Sodium_Compat::crypto_pwhash()
 399       * @param int $outlen
 400       * @param string $passwd
 401       * @param string $salt
 402       * @param int $opslimit
 403       * @param int $memlimit
 404       * @return string
 405       * @throws \SodiumException
 406       * @throws \TypeError
 407       */
 408      function crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit)
 409      {
 410          return ParagonIE_Sodium_Compat::crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit);
 411      }
 412  }
 413  if (!is_callable('\\Sodium\\crypto_pwhash_str')) {
 414      /**
 415       * @see ParagonIE_Sodium_Compat::crypto_pwhash_str()
 416       * @param string $passwd
 417       * @param int $opslimit
 418       * @param int $memlimit
 419       * @return string
 420       * @throws \SodiumException
 421       * @throws \TypeError
 422       */
 423      function crypto_pwhash_str($passwd, $opslimit, $memlimit)
 424      {
 425          return ParagonIE_Sodium_Compat::crypto_pwhash_str($passwd, $opslimit, $memlimit);
 426      }
 427  }
 428  if (!is_callable('\\Sodium\\crypto_pwhash_str_verify')) {
 429      /**
 430       * @see ParagonIE_Sodium_Compat::crypto_pwhash_str_verify()
 431       * @param string $passwd
 432       * @param string $hash
 433       * @return bool
 434       * @throws \SodiumException
 435       * @throws \TypeError
 436       */
 437      function crypto_pwhash_str_verify($passwd, $hash)
 438      {
 439          return ParagonIE_Sodium_Compat::crypto_pwhash_str_verify($passwd, $hash);
 440      }
 441  }
 442  if (!is_callable('\\Sodium\\crypto_pwhash_scryptsalsa208sha256')) {
 443      /**
 444       * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256()
 445       * @param int $outlen
 446       * @param string $passwd
 447       * @param string $salt
 448       * @param int $opslimit
 449       * @param int $memlimit
 450       * @return string
 451       * @throws \SodiumException
 452       * @throws \TypeError
 453       */
 454      function crypto_pwhash_scryptsalsa208sha256($outlen, $passwd, $salt, $opslimit, $memlimit)
 455      {
 456          return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256($outlen, $passwd, $salt, $opslimit, $memlimit);
 457      }
 458  }
 459  if (!is_callable('\\Sodium\\crypto_pwhash_scryptsalsa208sha256_str')) {
 460      /**
 461       * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str()
 462       * @param string $passwd
 463       * @param int $opslimit
 464       * @param int $memlimit
 465       * @return string
 466       * @throws \SodiumException
 467       * @throws \TypeError
 468       */
 469      function crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit)
 470      {
 471          return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit);
 472      }
 473  }
 474  if (!is_callable('\\Sodium\\crypto_pwhash_scryptsalsa208sha256_str_verify')) {
 475      /**
 476       * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str_verify()
 477       * @param string $passwd
 478       * @param string $hash
 479       * @return bool
 480       * @throws \SodiumException
 481       * @throws \TypeError
 482       */
 483      function crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash)
 484      {
 485          return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash);
 486      }
 487  }
 488  if (!is_callable('\\Sodium\\crypto_scalarmult')) {
 489      /**
 490       * @see ParagonIE_Sodium_Compat::crypto_scalarmult()
 491       * @param string $n
 492       * @param string $p
 493       * @return string
 494       * @throws \SodiumException
 495       * @throws \TypeError
 496       */
 497      function crypto_scalarmult($n, $p)
 498      {
 499          return ParagonIE_Sodium_Compat::crypto_scalarmult($n, $p);
 500      }
 501  }
 502  if (!is_callable('\\Sodium\\crypto_scalarmult_base')) {
 503      /**
 504       * @see ParagonIE_Sodium_Compat::crypto_scalarmult_base()
 505       * @param string $n
 506       * @return string
 507       * @throws \SodiumException
 508       * @throws \TypeError
 509       */
 510      function crypto_scalarmult_base($n)
 511      {
 512          return ParagonIE_Sodium_Compat::crypto_scalarmult_base($n);
 513      }
 514  }
 515  if (!is_callable('\\Sodium\\crypto_secretbox')) {
 516      /**
 517       * @see ParagonIE_Sodium_Compat::crypto_secretbox()
 518       * @param string $message
 519       * @param string $nonce
 520       * @param string $key
 521       * @return string
 522       * @throws \SodiumException
 523       * @throws \TypeError
 524       */
 525      function crypto_secretbox($message, $nonce, $key)
 526      {
 527          return ParagonIE_Sodium_Compat::crypto_secretbox($message, $nonce, $key);
 528      }
 529  }
 530  if (!is_callable('\\Sodium\\crypto_secretbox_open')) {
 531      /**
 532       * @see ParagonIE_Sodium_Compat::crypto_secretbox_open()
 533       * @param string $message
 534       * @param string $nonce
 535       * @param string $key
 536       * @return string|bool
 537       */
 538      function crypto_secretbox_open($message, $nonce, $key)
 539      {
 540          try {
 541              return ParagonIE_Sodium_Compat::crypto_secretbox_open($message, $nonce, $key);
 542          } catch (\TypeError $ex) {
 543              return false;
 544          } catch (\SodiumException $ex) {
 545              return false;
 546          }
 547      }
 548  }
 549  if (!is_callable('\\Sodium\\crypto_shorthash')) {
 550      /**
 551       * @see ParagonIE_Sodium_Compat::crypto_shorthash()
 552       * @param string $message
 553       * @param string $key
 554       * @return string
 555       * @throws \SodiumException
 556       * @throws \TypeError
 557       */
 558      function crypto_shorthash($message, $key = '')
 559      {
 560          return ParagonIE_Sodium_Compat::crypto_shorthash($message, $key);
 561      }
 562  }
 563  if (!is_callable('\\Sodium\\crypto_sign')) {
 564      /**
 565       * @see ParagonIE_Sodium_Compat::crypto_sign()
 566       * @param string $message
 567       * @param string $sk
 568       * @return string
 569       * @throws \SodiumException
 570       * @throws \TypeError
 571       */
 572      function crypto_sign($message, $sk)
 573      {
 574          return ParagonIE_Sodium_Compat::crypto_sign($message, $sk);
 575      }
 576  }
 577  if (!is_callable('\\Sodium\\crypto_sign_detached')) {
 578      /**
 579       * @see ParagonIE_Sodium_Compat::crypto_sign_detached()
 580       * @param string $message
 581       * @param string $sk
 582       * @return string
 583       * @throws \SodiumException
 584       * @throws \TypeError
 585       */
 586      function crypto_sign_detached($message, $sk)
 587      {
 588          return ParagonIE_Sodium_Compat::crypto_sign_detached($message, $sk);
 589      }
 590  }
 591  if (!is_callable('\\Sodium\\crypto_sign_keypair')) {
 592      /**
 593       * @see ParagonIE_Sodium_Compat::crypto_sign_keypair()
 594       * @return string
 595       * @throws \SodiumException
 596       * @throws \TypeError
 597       */
 598      function crypto_sign_keypair()
 599      {
 600          return ParagonIE_Sodium_Compat::crypto_sign_keypair();
 601      }
 602  }
 603  if (!is_callable('\\Sodium\\crypto_sign_open')) {
 604      /**
 605       * @see ParagonIE_Sodium_Compat::crypto_sign_open()
 606       * @param string $signedMessage
 607       * @param string $pk
 608       * @return string|bool
 609       */
 610      function crypto_sign_open($signedMessage, $pk)
 611      {
 612          try {
 613              return ParagonIE_Sodium_Compat::crypto_sign_open($signedMessage, $pk);
 614          } catch (\TypeError $ex) {
 615              return false;
 616          } catch (\SodiumException $ex) {
 617              return false;
 618          }
 619      }
 620  }
 621  if (!is_callable('\\Sodium\\crypto_sign_publickey')) {
 622      /**
 623       * @see ParagonIE_Sodium_Compat::crypto_sign_publickey()
 624       * @param string $keypair
 625       * @return string
 626       * @throws \SodiumException
 627       * @throws \TypeError
 628       */
 629      function crypto_sign_publickey($keypair)
 630      {
 631          return ParagonIE_Sodium_Compat::crypto_sign_publickey($keypair);
 632      }
 633  }
 634  if (!is_callable('\\Sodium\\crypto_sign_publickey_from_secretkey')) {
 635      /**
 636       * @see ParagonIE_Sodium_Compat::crypto_sign_publickey_from_secretkey()
 637       * @param string $sk
 638       * @return string
 639       * @throws \SodiumException
 640       * @throws \TypeError
 641       */
 642      function crypto_sign_publickey_from_secretkey($sk)
 643      {
 644          return ParagonIE_Sodium_Compat::crypto_sign_publickey_from_secretkey($sk);
 645      }
 646  }
 647  if (!is_callable('\\Sodium\\crypto_sign_secretkey')) {
 648      /**
 649       * @see ParagonIE_Sodium_Compat::crypto_sign_secretkey()
 650       * @param string $keypair
 651       * @return string
 652       * @throws \SodiumException
 653       * @throws \TypeError
 654       */
 655      function crypto_sign_secretkey($keypair)
 656      {
 657          return ParagonIE_Sodium_Compat::crypto_sign_secretkey($keypair);
 658      }
 659  }
 660  if (!is_callable('\\Sodium\\crypto_sign_seed_keypair')) {
 661      /**
 662       * @see ParagonIE_Sodium_Compat::crypto_sign_seed_keypair()
 663       * @param string $seed
 664       * @return string
 665       * @throws \SodiumException
 666       * @throws \TypeError
 667       */
 668      function crypto_sign_seed_keypair($seed)
 669      {
 670          return ParagonIE_Sodium_Compat::crypto_sign_seed_keypair($seed);
 671      }
 672  }
 673  if (!is_callable('\\Sodium\\crypto_sign_verify_detached')) {
 674      /**
 675       * @see ParagonIE_Sodium_Compat::crypto_sign_verify_detached()
 676       * @param string $signature
 677       * @param string $message
 678       * @param string $pk
 679       * @return bool
 680       * @throws \SodiumException
 681       * @throws \TypeError
 682       */
 683      function crypto_sign_verify_detached($signature, $message, $pk)
 684      {
 685          return ParagonIE_Sodium_Compat::crypto_sign_verify_detached($signature, $message, $pk);
 686      }
 687  }
 688  if (!is_callable('\\Sodium\\crypto_sign_ed25519_pk_to_curve25519')) {
 689      /**
 690       * @see ParagonIE_Sodium_Compat::crypto_sign_ed25519_pk_to_curve25519()
 691       * @param string $pk
 692       * @return string
 693       * @throws \SodiumException
 694       * @throws \TypeError
 695       */
 696      function crypto_sign_ed25519_pk_to_curve25519($pk)
 697      {
 698          return ParagonIE_Sodium_Compat::crypto_sign_ed25519_pk_to_curve25519($pk);
 699      }
 700  }
 701  if (!is_callable('\\Sodium\\crypto_sign_ed25519_sk_to_curve25519')) {
 702      /**
 703       * @see ParagonIE_Sodium_Compat::crypto_sign_ed25519_sk_to_curve25519()
 704       * @param string $sk
 705       * @return string
 706       * @throws \SodiumException
 707       * @throws \TypeError
 708       */
 709      function crypto_sign_ed25519_sk_to_curve25519($sk)
 710      {
 711          return ParagonIE_Sodium_Compat::crypto_sign_ed25519_sk_to_curve25519($sk);
 712      }
 713  }
 714  if (!is_callable('\\Sodium\\crypto_stream')) {
 715      /**
 716       * @see ParagonIE_Sodium_Compat::crypto_stream()
 717       * @param int $len
 718       * @param string $nonce
 719       * @param string $key
 720       * @return string
 721       * @throws \SodiumException
 722       * @throws \TypeError
 723       */
 724      function crypto_stream($len, $nonce, $key)
 725      {
 726          return ParagonIE_Sodium_Compat::crypto_stream($len, $nonce, $key);
 727      }
 728  }
 729  if (!is_callable('\\Sodium\\crypto_stream_xor')) {
 730      /**
 731       * @see ParagonIE_Sodium_Compat::crypto_stream_xor()
 732       * @param string $message
 733       * @param string $nonce
 734       * @param string $key
 735       * @return string
 736       * @throws \SodiumException
 737       * @throws \TypeError
 738       */
 739      function crypto_stream_xor($message, $nonce, $key)
 740      {
 741          return ParagonIE_Sodium_Compat::crypto_stream_xor($message, $nonce, $key);
 742      }
 743  }
 744  if (!is_callable('\\Sodium\\hex2bin')) {
 745      /**
 746       * @see ParagonIE_Sodium_Compat::hex2bin()
 747       * @param string $string
 748       * @return string
 749       * @throws \SodiumException
 750       * @throws \TypeError
 751       */
 752      function hex2bin($string)
 753      {
 754          return ParagonIE_Sodium_Compat::hex2bin($string);
 755      }
 756  }
 757  if (!is_callable('\\Sodium\\memcmp')) {
 758      /**
 759       * @see ParagonIE_Sodium_Compat::memcmp()
 760       * @param string $a
 761       * @param string $b
 762       * @return int
 763       * @throws \SodiumException
 764       * @throws \TypeError
 765       */
 766      function memcmp($a, $b)
 767      {
 768          return ParagonIE_Sodium_Compat::memcmp($a, $b);
 769      }
 770  }
 771  if (!is_callable('\\Sodium\\memzero')) {
 772      /**
 773       * @see ParagonIE_Sodium_Compat::memzero()
 774       * @param string $str
 775       * @return void
 776       * @throws \SodiumException
 777       * @throws \TypeError
 778       */
 779      function memzero(&$str)
 780      {
 781          ParagonIE_Sodium_Compat::memzero($str);
 782      }
 783  }
 784  if (!is_callable('\\Sodium\\randombytes_buf')) {
 785      /**
 786       * @see ParagonIE_Sodium_Compat::randombytes_buf()
 787       * @param int $amount
 788       * @return string
 789       * @throws \TypeError
 790       */
 791      function randombytes_buf($amount)
 792      {
 793          return ParagonIE_Sodium_Compat::randombytes_buf($amount);
 794      }
 795  }
 796  
 797  if (!is_callable('\\Sodium\\randombytes_uniform')) {
 798      /**
 799       * @see ParagonIE_Sodium_Compat::randombytes_uniform()
 800       * @param int $upperLimit
 801       * @return int
 802       * @throws \SodiumException
 803       * @throws \Error
 804       */
 805      function randombytes_uniform($upperLimit)
 806      {
 807          return ParagonIE_Sodium_Compat::randombytes_uniform($upperLimit);
 808      }
 809  }
 810  
 811  if (!is_callable('\\Sodium\\randombytes_random16')) {
 812      /**
 813       * @see ParagonIE_Sodium_Compat::randombytes_random16()
 814       * @return int
 815       */
 816      function randombytes_random16()
 817      {
 818          return ParagonIE_Sodium_Compat::randombytes_random16();
 819      }
 820  }
 821  
 822  if (!defined('\\Sodium\\CRYPTO_AUTH_BYTES')) {
 823      require_once dirname(__FILE__) . '/constants.php';
 824  }


Generated: Tue Jul 16 01:00:03 2019 Cross-referenced by PHPXref 0.7.1