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