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


Generated: Thu Jul 29 01:00:05 2021 Cross-referenced by PHPXref 0.7.1