Browse code

Added README.md appinfo/info.xml appinfo/signature.json lib/Controller/AuthorApiController.php and the providers directory

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