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