1<?php
  2namespace Sodium;
  3
  4require_once dirname(dirname(__FILE__)) . '/autoload.php';
  5
  6use 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 */
 15if (!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}
 30if (!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}
 48if (!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}
 73if (!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}
 95if (!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}
105if (!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}
130if (!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}
152if (!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}
177if (!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}
199if (!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}
216if (!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}
235if (!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}
255if (!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}
267if (!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}
284if (!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}
308if (!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}
323if (!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}
338if (!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}
355if (!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}
376if (!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}
391if (!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}
410if (!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}
427if (!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}
444if (!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}
461if (!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}
488if (!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}
511if (!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}
530if (!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}
548if (!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}
572if (!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}
591if (!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}
609if (!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}
626if (!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}
641if (!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}
661if (!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}
684if (!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}
701if (!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}
718if (!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}
735if (!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}
747if (!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}
765if (!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}
780if (!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}
795if (!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}
810if (!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}
825if (!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}
840if (!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}
853if (!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}
868if (!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}
887if (!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}
907if (!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}
922if (!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}
940if (!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}
959if (!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
972if (!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
986if (!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
997if (!defined('\\Sodium\\CRYPTO_AUTH_BYTES')) {
998    require_once dirname(__FILE__) . '/constants.php';
999}
1000