Diff: STRATO-apps/wordpress_03/app/wp-includes/sodium_compat/lib/sodium_compat.php

Keine Baseline-Datei – Diff nur gegen leer.
Baseline Vorherige Version
Zur Liste
1 -
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(
24 + #[\SensitiveParameter]
25 + $string
26 + ) {
27 + return ParagonIE_Sodium_Compat::bin2hex($string);
28 + }
29 + }
30 + if (!is_callable('\\Sodium\\compare')) {
31 + /**
32 + * @see ParagonIE_Sodium_Compat::compare()
33 + * @param string $a
34 + * @param string $b
35 + * @return int
36 + * @throws \SodiumException
37 + * @throws \TypeError
38 + */
39 + function compare(
40 + #[\SensitiveParameter]
41 + $a,
42 + #[\SensitiveParameter]
43 + $b
44 + ) {
45 + return ParagonIE_Sodium_Compat::compare($a, $b);
46 + }
47 + }
48 + if (!is_callable('\\Sodium\\crypto_aead_aes256gcm_decrypt')) {
49 + /**
50 + * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt()
51 + * @param string $message
52 + * @param string $assocData
53 + * @param string $nonce
54 + * @param string $key
55 + * @return string|bool
56 + */
57 + function crypto_aead_aes256gcm_decrypt(
58 + $message,
59 + $assocData,
60 + $nonce,
61 + #[\SensitiveParameter]
62 + $key
63 + ) {
64 + try {
65 + return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key);
66 + } catch (\TypeError $ex) {
67 + return false;
68 + } catch (\SodiumException $ex) {
69 + return false;
70 + }
71 + }
72 + }
73 + if (!is_callable('\\Sodium\\crypto_aead_aes256gcm_encrypt')) {
74 + /**
75 + * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt()
76 + * @param string $message
77 + * @param string $assocData
78 + * @param string $nonce
79 + * @param string $key
80 + * @return string
81 + * @throws \SodiumException
82 + * @throws \TypeError
83 + */
84 + function crypto_aead_aes256gcm_encrypt(
85 + #[\SensitiveParameter]
86 + $message,
87 + $assocData,
88 + $nonce,
89 + #[\SensitiveParameter]
90 + $key
91 + ) {
92 + return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt($message, $assocData, $nonce, $key);
93 + }
94 + }
95 + if (!is_callable('\\Sodium\\crypto_aead_aes256gcm_is_available')) {
96 + /**
97 + * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_is_available()
98 + * @return bool
99 + */
100 + function crypto_aead_aes256gcm_is_available()
101 + {
102 + return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_is_available();
103 + }
104 + }
105 + if (!is_callable('\\Sodium\\crypto_aead_chacha20poly1305_decrypt')) {
106 + /**
107 + * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt()
108 + * @param string $message
109 + * @param string $assocData
110 + * @param string $nonce
111 + * @param string $key
112 + * @return string|bool
113 + */
114 + function crypto_aead_chacha20poly1305_decrypt(
115 + $message,
116 + $assocData,
117 + $nonce,
118 + #[\SensitiveParameter]
119 + $key
120 + ) {
121 + try {
122 + return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key);
123 + } catch (\TypeError $ex) {
124 + return false;
125 + } catch (\SodiumException $ex) {
126 + return false;
127 + }
128 + }
129 + }
130 + if (!is_callable('\\Sodium\\crypto_aead_chacha20poly1305_encrypt')) {
131 + /**
132 + * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt()
133 + * @param string $message
134 + * @param string $assocData
135 + * @param string $nonce
136 + * @param string $key
137 + * @return string
138 + * @throws \SodiumException
139 + * @throws \TypeError
140 + */
141 + function crypto_aead_chacha20poly1305_encrypt(
142 + #[\SensitiveParameter]
143 + $message,
144 + $assocData,
145 + $nonce,
146 + #[\SensitiveParameter]
147 + $key
148 + ) {
149 + return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt($message, $assocData, $nonce, $key);
150 + }
151 + }
152 + if (!is_callable('\\Sodium\\crypto_aead_chacha20poly1305_ietf_decrypt')) {
153 + /**
154 + * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt()
155 + * @param string $message
156 + * @param string $assocData
157 + * @param string $nonce
158 + * @param string $key
159 + * @return string|bool
160 + */
161 + function crypto_aead_chacha20poly1305_ietf_decrypt(
162 + $message,
163 + $assocData,
164 + $nonce,
165 + #[\SensitiveParameter]
166 + $key
167 + ) {
168 + try {
169 + return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key);
170 + } catch (\TypeError $ex) {
171 + return false;
172 + } catch (\SodiumException $ex) {
173 + return false;
174 + }
175 + }
176 + }
177 + if (!is_callable('\\Sodium\\crypto_aead_chacha20poly1305_ietf_encrypt')) {
178 + /**
179 + * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt()
180 + * @param string $message
181 + * @param string $assocData
182 + * @param string $nonce
183 + * @param string $key
184 + * @return string
185 + * @throws \SodiumException
186 + * @throws \TypeError
187 + */
188 + function crypto_aead_chacha20poly1305_ietf_encrypt(
189 + #[\SensitiveParameter]
190 + $message,
191 + $assocData,
192 + $nonce,
193 + #[\SensitiveParameter]
194 + $key
195 + ) {
196 + return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key);
197 + }
198 + }
199 + if (!is_callable('\\Sodium\\crypto_auth')) {
200 + /**
201 + * @see ParagonIE_Sodium_Compat::crypto_auth()
202 + * @param string $message
203 + * @param string $key
204 + * @return string
205 + * @throws \SodiumException
206 + * @throws \TypeError
207 + */
208 + function crypto_auth(
209 + $message,
210 + #[\SensitiveParameter]
211 + $key
212 + ) {
213 + return ParagonIE_Sodium_Compat::crypto_auth($message, $key);
214 + }
215 + }
216 + if (!is_callable('\\Sodium\\crypto_auth_verify')) {
217 + /**
218 + * @see ParagonIE_Sodium_Compat::crypto_auth_verify()
219 + * @param string $mac
220 + * @param string $message
221 + * @param string $key
222 + * @return bool
223 + * @throws \SodiumException
224 + * @throws \TypeError
225 + */
226 + function crypto_auth_verify(
227 + $mac,
228 + $message,
229 + #[\SensitiveParameter]
230 + $key
231 + ) {
232 + return ParagonIE_Sodium_Compat::crypto_auth_verify($mac, $message, $key);
233 + }
234 + }
235 + if (!is_callable('\\Sodium\\crypto_box')) {
236 + /**
237 + * @see ParagonIE_Sodium_Compat::crypto_box()
238 + * @param string $message
239 + * @param string $nonce
240 + * @param string $kp
241 + * @return string
242 + * @throws \SodiumException
243 + * @throws \TypeError
244 + */
245 + function crypto_box(
246 + #[\SensitiveParameter]
247 + $message,
248 + $nonce,
249 + #[\SensitiveParameter]
250 + $kp
251 + ) {
252 + return ParagonIE_Sodium_Compat::crypto_box($message, $nonce, $kp);
253 + }
254 + }
255 + if (!is_callable('\\Sodium\\crypto_box_keypair')) {
256 + /**
257 + * @see ParagonIE_Sodium_Compat::crypto_box_keypair()
258 + * @return string
259 + * @throws \SodiumException
260 + * @throws \TypeError
261 + */
262 + function crypto_box_keypair()
263 + {
264 + return ParagonIE_Sodium_Compat::crypto_box_keypair();
265 + }
266 + }
267 + if (!is_callable('\\Sodium\\crypto_box_keypair_from_secretkey_and_publickey')) {
268 + /**
269 + * @see ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey()
270 + * @param string $sk
271 + * @param string $pk
272 + * @return string
273 + * @throws \SodiumException
274 + * @throws \TypeError
275 + */
276 + function crypto_box_keypair_from_secretkey_and_publickey(
277 + #[\SensitiveParameter]
278 + $sk,
279 + $pk
280 + ) {
281 + return ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey($sk, $pk);
282 + }
283 + }
284 + if (!is_callable('\\Sodium\\crypto_box_open')) {
285 + /**
286 + * @see ParagonIE_Sodium_Compat::crypto_box_open()
287 + * @param string $message
288 + * @param string $nonce
289 + * @param string $kp
290 + * @return string|bool
291 + */
292 + function crypto_box_open(
293 + #[\SensitiveParameter]
294 + $message,
295 + $nonce,
296 + #[\SensitiveParameter]
297 + $kp
298 + ) {
299 + try {
300 + return ParagonIE_Sodium_Compat::crypto_box_open($message, $nonce, $kp);
301 + } catch (\TypeError $ex) {
302 + return false;
303 + } catch (\SodiumException $ex) {
304 + return false;
305 + }
306 + }
307 + }
308 + if (!is_callable('\\Sodium\\crypto_box_publickey')) {
309 + /**
310 + * @see ParagonIE_Sodium_Compat::crypto_box_publickey()
311 + * @param string $keypair
312 + * @return string
313 + * @throws \SodiumException
314 + * @throws \TypeError
315 + */
316 + function crypto_box_publickey(
317 + #[\SensitiveParameter]
318 + $keypair
319 + ) {
320 + return ParagonIE_Sodium_Compat::crypto_box_publickey($keypair);
321 + }
322 + }
323 + if (!is_callable('\\Sodium\\crypto_box_publickey_from_secretkey')) {
324 + /**
325 + * @see ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey()
326 + * @param string $sk
327 + * @return string
328 + * @throws \SodiumException
329 + * @throws \TypeError
330 + */
331 + function crypto_box_publickey_from_secretkey(
332 + #[\SensitiveParameter]
333 + $sk
334 + ) {
335 + return ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey($sk);
336 + }
337 + }
338 + if (!is_callable('\\Sodium\\crypto_box_seal')) {
339 + /**
340 + * @see ParagonIE_Sodium_Compat::crypto_box_seal_open()
341 + * @param string $message
342 + * @param string $publicKey
343 + * @return string
344 + * @throws \SodiumException
345 + * @throws \TypeError
346 + */
347 + function crypto_box_seal(
348 + #[\SensitiveParameter]
349 + $message,
350 + $publicKey
351 + ) {
352 + return ParagonIE_Sodium_Compat::crypto_box_seal($message, $publicKey);
353 + }
354 + }
355 + if (!is_callable('\\Sodium\\crypto_box_seal_open')) {
356 + /**
357 + * @see ParagonIE_Sodium_Compat::crypto_box_seal_open()
358 + * @param string $message
359 + * @param string $kp
360 + * @return string|bool
361 + */
362 + function crypto_box_seal_open(
363 + $message,
364 + #[\SensitiveParameter]
365 + $kp
366 + ) {
367 + try {
368 + return ParagonIE_Sodium_Compat::crypto_box_seal_open($message, $kp);
369 + } catch (\TypeError $ex) {
370 + return false;
371 + } catch (\SodiumException $ex) {
372 + return false;
373 + }
374 + }
375 + }
376 + if (!is_callable('\\Sodium\\crypto_box_secretkey')) {
377 + /**
378 + * @see ParagonIE_Sodium_Compat::crypto_box_secretkey()
379 + * @param string $keypair
380 + * @return string
381 + * @throws \SodiumException
382 + * @throws \TypeError
383 + */
384 + function crypto_box_secretkey(
385 + #[\SensitiveParameter]
386 + $keypair
387 + ) {
388 + return ParagonIE_Sodium_Compat::crypto_box_secretkey($keypair);
389 + }
390 + }
391 + if (!is_callable('\\Sodium\\crypto_generichash')) {
392 + /**
393 + * @see ParagonIE_Sodium_Compat::crypto_generichash()
394 + * @param string $message
395 + * @param string|null $key
396 + * @param int $outLen
397 + * @return string
398 + * @throws \SodiumException
399 + * @throws \TypeError
400 + */
401 + function crypto_generichash(
402 + $message,
403 + #[\SensitiveParameter]
404 + $key = null,
405 + $outLen = 32
406 + ) {
407 + return ParagonIE_Sodium_Compat::crypto_generichash($message, $key, $outLen);
408 + }
409 + }
410 + if (!is_callable('\\Sodium\\crypto_generichash_final')) {
411 + /**
412 + * @see ParagonIE_Sodium_Compat::crypto_generichash_final()
413 + * @param string|null $ctx
414 + * @param int $outputLength
415 + * @return string
416 + * @throws \SodiumException
417 + * @throws \TypeError
418 + */
419 + function crypto_generichash_final(
420 + #[\SensitiveParameter]
421 + &$ctx,
422 + $outputLength = 32
423 + ) {
424 + return ParagonIE_Sodium_Compat::crypto_generichash_final($ctx, $outputLength);
425 + }
426 + }
427 + if (!is_callable('\\Sodium\\crypto_generichash_init')) {
428 + /**
429 + * @see ParagonIE_Sodium_Compat::crypto_generichash_init()
430 + * @param string|null $key
431 + * @param int $outLen
432 + * @return string
433 + * @throws \SodiumException
434 + * @throws \TypeError
435 + */
436 + function crypto_generichash_init(
437 + #[\SensitiveParameter]
438 + $key = null,
439 + $outLen = 32
440 + ) {
441 + return ParagonIE_Sodium_Compat::crypto_generichash_init($key, $outLen);
442 + }
443 + }
444 + if (!is_callable('\\Sodium\\crypto_generichash_update')) {
445 + /**
446 + * @see ParagonIE_Sodium_Compat::crypto_generichash_update()
447 + * @param string|null $ctx
448 + * @param string $message
449 + * @return void
450 + * @throws \SodiumException
451 + * @throws \TypeError
452 + */
453 + function crypto_generichash_update(
454 + #[\SensitiveParameter]
455 + &$ctx,
456 + $message = ''
457 + ) {
458 + ParagonIE_Sodium_Compat::crypto_generichash_update($ctx, $message);
459 + }
460 + }
461 + if (!is_callable('\\Sodium\\crypto_kx')) {
462 + /**
463 + * @see ParagonIE_Sodium_Compat::crypto_kx()
464 + * @param string $my_secret
465 + * @param string $their_public
466 + * @param string $client_public
467 + * @param string $server_public
468 + * @return string
469 + * @throws \SodiumException
470 + * @throws \TypeError
471 + */
472 + function crypto_kx(
473 + #[\SensitiveParameter]
474 + $my_secret,
475 + $their_public,
476 + $client_public,
477 + $server_public
478 + ) {
479 + return ParagonIE_Sodium_Compat::crypto_kx(
480 + $my_secret,
481 + $their_public,
482 + $client_public,
483 + $server_public,
484 + true
485 + );
486 + }
487 + }
488 + if (!is_callable('\\Sodium\\crypto_pwhash')) {
489 + /**
490 + * @see ParagonIE_Sodium_Compat::crypto_pwhash()
491 + * @param int $outlen
492 + * @param string $passwd
493 + * @param string $salt
494 + * @param int $opslimit
495 + * @param int $memlimit
496 + * @return string
497 + * @throws \SodiumException
498 + * @throws \TypeError
499 + */
500 + function crypto_pwhash(
501 + $outlen,
502 + #[\SensitiveParameter]
503 + $passwd,
504 + $salt,
505 + $opslimit,
506 + $memlimit
507 + ) {
508 + return ParagonIE_Sodium_Compat::crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit);
509 + }
510 + }
511 + if (!is_callable('\\Sodium\\crypto_pwhash_str')) {
512 + /**
513 + * @see ParagonIE_Sodium_Compat::crypto_pwhash_str()
514 + * @param string $passwd
515 + * @param int $opslimit
516 + * @param int $memlimit
517 + * @return string
518 + * @throws \SodiumException
519 + * @throws \TypeError
520 + */
521 + function crypto_pwhash_str(
522 + #[\SensitiveParameter]
523 + $passwd,
524 + $opslimit,
525 + $memlimit
526 + ) {
527 + return ParagonIE_Sodium_Compat::crypto_pwhash_str($passwd, $opslimit, $memlimit);
528 + }
529 + }
530 + if (!is_callable('\\Sodium\\crypto_pwhash_str_verify')) {
531 + /**
532 + * @see ParagonIE_Sodium_Compat::crypto_pwhash_str_verify()
533 + * @param string $passwd
534 + * @param string $hash
535 + * @return bool
536 + * @throws \SodiumException
537 + * @throws \TypeError
538 + */
539 + function crypto_pwhash_str_verify(
540 + #[\SensitiveParameter]
541 + $passwd,
542 + #[\SensitiveParameter]
543 + $hash
544 + ) {
545 + return ParagonIE_Sodium_Compat::crypto_pwhash_str_verify($passwd, $hash);
546 + }
547 + }
548 + if (!is_callable('\\Sodium\\crypto_pwhash_scryptsalsa208sha256')) {
549 + /**
550 + * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256()
551 + * @param int $outlen
552 + * @param string $passwd
553 + * @param string $salt
554 + * @param int $opslimit
555 + * @param int $memlimit
556 + * @return string
557 + * @throws \SodiumException
558 + * @throws \TypeError
559 + */
560 + function crypto_pwhash_scryptsalsa208sha256(
561 + $outlen,
562 + #[\SensitiveParameter]
563 + $passwd,
564 + #[\SensitiveParameter]
565 + $salt,
566 + $opslimit,
567 + $memlimit
568 + ) {
569 + return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256($outlen, $passwd, $salt, $opslimit, $memlimit);
570 + }
571 + }
572 + if (!is_callable('\\Sodium\\crypto_pwhash_scryptsalsa208sha256_str')) {
573 + /**
574 + * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str()
575 + * @param string $passwd
576 + * @param int $opslimit
577 + * @param int $memlimit
578 + * @return string
579 + * @throws \SodiumException
580 + * @throws \TypeError
581 + */
582 + function crypto_pwhash_scryptsalsa208sha256_str(
583 + #[\SensitiveParameter]
584 + $passwd,
585 + $opslimit,
586 + $memlimit
587 + ) {
588 + return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit);
589 + }
590 + }
591 + if (!is_callable('\\Sodium\\crypto_pwhash_scryptsalsa208sha256_str_verify')) {
592 + /**
593 + * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str_verify()
594 + * @param string $passwd
595 + * @param string $hash
596 + * @return bool
597 + * @throws \SodiumException
598 + * @throws \TypeError
599 + */
600 + function crypto_pwhash_scryptsalsa208sha256_str_verify(
601 + #[\SensitiveParameter]
602 + $passwd,
603 + #[\SensitiveParameter]
604 + $hash
605 + ) {
606 + return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash);
607 + }
608 + }
609 + if (!is_callable('\\Sodium\\crypto_scalarmult')) {
610 + /**
611 + * @see ParagonIE_Sodium_Compat::crypto_scalarmult()
612 + * @param string $n
613 + * @param string $p
614 + * @return string
615 + * @throws \SodiumException
616 + * @throws \TypeError
617 + */
618 + function crypto_scalarmult(
619 + #[\SensitiveParameter]
620 + $n,
621 + $p
622 + ) {
623 + return ParagonIE_Sodium_Compat::crypto_scalarmult($n, $p);
624 + }
625 + }
626 + if (!is_callable('\\Sodium\\crypto_scalarmult_base')) {
627 + /**
628 + * @see ParagonIE_Sodium_Compat::crypto_scalarmult_base()
629 + * @param string $n
630 + * @return string
631 + * @throws \SodiumException
632 + * @throws \TypeError
633 + */
634 + function crypto_scalarmult_base(
635 + #[\SensitiveParameter]
636 + $n
637 + ) {
638 + return ParagonIE_Sodium_Compat::crypto_scalarmult_base($n);
639 + }
640 + }
641 + if (!is_callable('\\Sodium\\crypto_secretbox')) {
642 + /**
643 + * @see ParagonIE_Sodium_Compat::crypto_secretbox()
644 + * @param string $message
645 + * @param string $nonce
646 + * @param string $key
647 + * @return string
648 + * @throws \SodiumException
649 + * @throws \TypeError
650 + */
651 + function crypto_secretbox(
652 + #[\SensitiveParameter]
653 + $message,
654 + $nonce,
655 + #[\SensitiveParameter]
656 + $key
657 + ) {
658 + return ParagonIE_Sodium_Compat::crypto_secretbox($message, $nonce, $key);
659 + }
660 + }
661 + if (!is_callable('\\Sodium\\crypto_secretbox_open')) {
662 + /**
663 + * @see ParagonIE_Sodium_Compat::crypto_secretbox_open()
664 + * @param string $message
665 + * @param string $nonce
666 + * @param string $key
667 + * @return string|bool
668 + */
669 + function crypto_secretbox_open(
670 + $message,
671 + $nonce,
672 + #[\SensitiveParameter]
673 + $key
674 + ) {
675 + try {
676 + return ParagonIE_Sodium_Compat::crypto_secretbox_open($message, $nonce, $key);
677 + } catch (\TypeError $ex) {
678 + return false;
679 + } catch (\SodiumException $ex) {
680 + return false;
681 + }
682 + }
683 + }
684 + if (!is_callable('\\Sodium\\crypto_shorthash')) {
685 + /**
686 + * @see ParagonIE_Sodium_Compat::crypto_shorthash()
687 + * @param string $message
688 + * @param string $key
689 + * @return string
690 + * @throws \SodiumException
691 + * @throws \TypeError
692 + */
693 + function crypto_shorthash(
694 + $message,
695 + #[\SensitiveParameter]
696 + $key = ''
697 + ) {
698 + return ParagonIE_Sodium_Compat::crypto_shorthash($message, $key);
699 + }
700 + }
701 + if (!is_callable('\\Sodium\\crypto_sign')) {
702 + /**
703 + * @see ParagonIE_Sodium_Compat::crypto_sign()
704 + * @param string $message
705 + * @param string $sk
706 + * @return string
707 + * @throws \SodiumException
708 + * @throws \TypeError
709 + */
710 + function crypto_sign(
711 + $message,
712 + #[\SensitiveParameter]
713 + $sk
714 + ) {
715 + return ParagonIE_Sodium_Compat::crypto_sign($message, $sk);
716 + }
717 + }
718 + if (!is_callable('\\Sodium\\crypto_sign_detached')) {
719 + /**
720 + * @see ParagonIE_Sodium_Compat::crypto_sign_detached()
721 + * @param string $message
722 + * @param string $sk
723 + * @return string
724 + * @throws \SodiumException
725 + * @throws \TypeError
726 + */
727 + function crypto_sign_detached(
728 + $message,
729 + #[\SensitiveParameter]
730 + $sk
731 + ) {
732 + return ParagonIE_Sodium_Compat::crypto_sign_detached($message, $sk);
733 + }
734 + }
735 + if (!is_callable('\\Sodium\\crypto_sign_keypair')) {
736 + /**
737 + * @see ParagonIE_Sodium_Compat::crypto_sign_keypair()
738 + * @return string
739 + * @throws \SodiumException
740 + * @throws \TypeError
741 + */
742 + function crypto_sign_keypair()
743 + {
744 + return ParagonIE_Sodium_Compat::crypto_sign_keypair();
745 + }
746 + }
747 + if (!is_callable('\\Sodium\\crypto_sign_open')) {
748 + /**
749 + * @see ParagonIE_Sodium_Compat::crypto_sign_open()
750 + * @param string $signedMessage
751 + * @param string $pk
752 + * @return string|bool
753 + */
754 + function crypto_sign_open($signedMessage, $pk)
755 + {
756 + try {
757 + return ParagonIE_Sodium_Compat::crypto_sign_open($signedMessage, $pk);
758 + } catch (\TypeError $ex) {
759 + return false;
760 + } catch (\SodiumException $ex) {
761 + return false;
762 + }
763 + }
764 + }
765 + if (!is_callable('\\Sodium\\crypto_sign_publickey')) {
766 + /**
767 + * @see ParagonIE_Sodium_Compat::crypto_sign_publickey()
768 + * @param string $keypair
769 + * @return string
770 + * @throws \SodiumException
771 + * @throws \TypeError
772 + */
773 + function crypto_sign_publickey(
774 + #[\SensitiveParameter]
775 + $keypair
776 + ) {
777 + return ParagonIE_Sodium_Compat::crypto_sign_publickey($keypair);
778 + }
779 + }
780 + if (!is_callable('\\Sodium\\crypto_sign_publickey_from_secretkey')) {
781 + /**
782 + * @see ParagonIE_Sodium_Compat::crypto_sign_publickey_from_secretkey()
783 + * @param string $sk
784 + * @return string
785 + * @throws \SodiumException
786 + * @throws \TypeError
787 + */
788 + function crypto_sign_publickey_from_secretkey(
789 + #[\SensitiveParameter]
790 + $sk
791 + ) {
792 + return ParagonIE_Sodium_Compat::crypto_sign_publickey_from_secretkey($sk);
793 + }
794 + }
795 + if (!is_callable('\\Sodium\\crypto_sign_secretkey')) {
796 + /**
797 + * @see ParagonIE_Sodium_Compat::crypto_sign_secretkey()
798 + * @param string $keypair
799 + * @return string
800 + * @throws \SodiumException
801 + * @throws \TypeError
802 + */
803 + function crypto_sign_secretkey(
804 + #[\SensitiveParameter]
805 + $keypair
806 + ) {
807 + return ParagonIE_Sodium_Compat::crypto_sign_secretkey($keypair);
808 + }
809 + }
810 + if (!is_callable('\\Sodium\\crypto_sign_seed_keypair')) {
811 + /**
812 + * @see ParagonIE_Sodium_Compat::crypto_sign_seed_keypair()
813 + * @param string $seed
814 + * @return string
815 + * @throws \SodiumException
816 + * @throws \TypeError
817 + */
818 + function crypto_sign_seed_keypair(
819 + #[\SensitiveParameter]
820 + $seed
821 + ) {
822 + return ParagonIE_Sodium_Compat::crypto_sign_seed_keypair($seed);
823 + }
824 + }
825 + if (!is_callable('\\Sodium\\crypto_sign_verify_detached')) {
826 + /**
827 + * @see ParagonIE_Sodium_Compat::crypto_sign_verify_detached()
828 + * @param string $signature
829 + * @param string $message
830 + * @param string $pk
831 + * @return bool
832 + * @throws \SodiumException
833 + * @throws \TypeError
834 + */
835 + function crypto_sign_verify_detached($signature, $message, $pk)
836 + {
837 + return ParagonIE_Sodium_Compat::crypto_sign_verify_detached($signature, $message, $pk);
838 + }
839 + }
840 + if (!is_callable('\\Sodium\\crypto_sign_ed25519_pk_to_curve25519')) {
841 + /**
842 + * @see ParagonIE_Sodium_Compat::crypto_sign_ed25519_pk_to_curve25519()
843 + * @param string $pk
844 + * @return string
845 + * @throws \SodiumException
846 + * @throws \TypeError
847 + */
848 + function crypto_sign_ed25519_pk_to_curve25519($pk)
849 + {
850 + return ParagonIE_Sodium_Compat::crypto_sign_ed25519_pk_to_curve25519($pk);
851 + }
852 + }
853 + if (!is_callable('\\Sodium\\crypto_sign_ed25519_sk_to_curve25519')) {
854 + /**
855 + * @see ParagonIE_Sodium_Compat::crypto_sign_ed25519_sk_to_curve25519()
856 + * @param string $sk
857 + * @return string
858 + * @throws \SodiumException
859 + * @throws \TypeError
860 + */
861 + function crypto_sign_ed25519_sk_to_curve25519(
862 + #[\SensitiveParameter]
863 + $sk
864 + ) {
865 + return ParagonIE_Sodium_Compat::crypto_sign_ed25519_sk_to_curve25519($sk);
866 + }
867 + }
868 + if (!is_callable('\\Sodium\\crypto_stream')) {
869 + /**
870 + * @see ParagonIE_Sodium_Compat::crypto_stream()
871 + * @param int $len
872 + * @param string $nonce
873 + * @param string $key
874 + * @return string
875 + * @throws \SodiumException
876 + * @throws \TypeError
877 + */
878 + function crypto_stream(
879 + $len,
880 + $nonce,
881 + #[\SensitiveParameter]
882 + $key
883 + ) {
884 + return ParagonIE_Sodium_Compat::crypto_stream($len, $nonce, $key);
885 + }
886 + }
887 + if (!is_callable('\\Sodium\\crypto_stream_xor')) {
888 + /**
889 + * @see ParagonIE_Sodium_Compat::crypto_stream_xor()
890 + * @param string $message
891 + * @param string $nonce
892 + * @param string $key
893 + * @return string
894 + * @throws \SodiumException
895 + * @throws \TypeError
896 + */
897 + function crypto_stream_xor(
898 + #[\SensitiveParameter]
899 + $message,
900 + $nonce,
901 + #[\SensitiveParameter]
902 + $key
903 + ) {
904 + return ParagonIE_Sodium_Compat::crypto_stream_xor($message, $nonce, $key);
905 + }
906 + }
907 + if (!is_callable('\\Sodium\\hex2bin')) {
908 + /**
909 + * @see ParagonIE_Sodium_Compat::hex2bin()
910 + * @param string $string
911 + * @return string
912 + * @throws \SodiumException
913 + * @throws \TypeError
914 + */
915 + function hex2bin(
916 + #[\SensitiveParameter]
917 + $string
918 + ) {
919 + return ParagonIE_Sodium_Compat::hex2bin($string);
920 + }
921 + }
922 + if (!is_callable('\\Sodium\\memcmp')) {
923 + /**
924 + * @see ParagonIE_Sodium_Compat::memcmp()
925 + * @param string $a
926 + * @param string $b
927 + * @return int
928 + * @throws \SodiumException
929 + * @throws \TypeError
930 + */
931 + function memcmp(
932 + #[\SensitiveParameter]
933 + $a,
934 + #[\SensitiveParameter]
935 + $b
936 + ) {
937 + return ParagonIE_Sodium_Compat::memcmp($a, $b);
938 + }
939 + }
940 + if (!is_callable('\\Sodium\\memzero')) {
941 + /**
942 + * @see ParagonIE_Sodium_Compat::memzero()
943 + * @param string $str
944 + * @return void
945 + * @throws \SodiumException
946 + * @throws \TypeError
947 + *
948 + * @psalm-suppress MissingParamType
949 + * @psalm-suppress MissingReturnType
950 + * @psalm-suppress ReferenceConstraintViolation
951 + */
952 + function memzero(
953 + #[\SensitiveParameter]
954 + &$str
955 + ) {
956 + ParagonIE_Sodium_Compat::memzero($str);
957 + }
958 + }
959 + if (!is_callable('\\Sodium\\randombytes_buf')) {
960 + /**
961 + * @see ParagonIE_Sodium_Compat::randombytes_buf()
962 + * @param int $amount
963 + * @return string
964 + * @throws \TypeError
965 + */
966 + function randombytes_buf($amount)
967 + {
968 + return ParagonIE_Sodium_Compat::randombytes_buf($amount);
969 + }
970 + }
971 +
972 + if (!is_callable('\\Sodium\\randombytes_uniform')) {
973 + /**
974 + * @see ParagonIE_Sodium_Compat::randombytes_uniform()
975 + * @param int $upperLimit
976 + * @return int
977 + * @throws \SodiumException
978 + * @throws \Error
979 + */
980 + function randombytes_uniform($upperLimit)
981 + {
982 + return ParagonIE_Sodium_Compat::randombytes_uniform($upperLimit);
983 + }
984 + }
985 +
986 + if (!is_callable('\\Sodium\\randombytes_random16')) {
987 + /**
988 + * @see ParagonIE_Sodium_Compat::randombytes_random16()
989 + * @return int
990 + */
991 + function randombytes_random16()
992 + {
993 + return ParagonIE_Sodium_Compat::randombytes_random16();
994 + }
995 + }
996 +
997 + if (!defined('\\Sodium\\CRYPTO_AUTH_BYTES')) {
998 + require_once dirname(__FILE__) . '/constants.php';
999 + }
1000 +