react-native-quick-crypto 1.0.0-beta.17 → 1.0.0-beta.19

package/ios/libsodium-stable/test/default/sign.exp

@@ -0,0 +1,5 @@
+1024 tests
+ed25519ph sig: [10c5411e40bd10170fb890d4dfdb6d338c8cb11d2764a216ee54df10977dcdefd8ff755b1eeb3f16fce80e40e7aafc99083dbff43d5031baf04157b48423960d]
+ed25519ph tv sig: [98a70222f0b8121aa9d30f813d683f809e462b469c7ff87639499bb94e6dae4131f85042463c2a355a2003d062adf5aaa10b8c61e636062aaad11c2a26083406]
+pk: [b5076a8474a832daee4dd5b4040983b6623b5f344aca57d4d6ee4baf3f259e6e]
+sk: [421151a459faeade3d247115f94aedae42318124095afabe4d1451a559faedeeb5076a8474a832daee4dd5b4040983b6623b5f344aca57d4d6ee4baf3f259e6e]

package/ios/libsodium-stable/test/default/siphashx24.c

@@ -0,0 +1,33 @@
+
+#define TEST_NAME "siphashx24"
+#include "cmptest.h"
+
+#define MAXLEN 64
+
+int
+main(void)
+{
+    unsigned char in[MAXLEN];
+    unsigned char out[crypto_shorthash_siphashx24_BYTES];
+    unsigned char k[crypto_shorthash_siphashx24_KEYBYTES];
+    size_t        i;
+    size_t        j;
+
+    for (i = 0; i < crypto_shorthash_siphashx24_KEYBYTES; ++i) {
+        k[i] = (unsigned char) i;
+    }
+    for (i = 0; i < MAXLEN; ++i) {
+        in[i] = (unsigned char) i;
+        crypto_shorthash_siphashx24(out, in, (unsigned long long) i, k);
+        for (j = 0; j < crypto_shorthash_siphashx24_BYTES; ++j) {
+            printf("%02x", (unsigned int) out[j]);
+        }
+        printf("\n");
+    }
+    assert(crypto_shorthash_siphashx24_KEYBYTES >= crypto_shorthash_siphash24_KEYBYTES);
+    assert(crypto_shorthash_siphashx24_BYTES > crypto_shorthash_siphash24_BYTES);
+    assert(crypto_shorthash_siphashx24_bytes() == crypto_shorthash_siphashx24_BYTES);
+    assert(crypto_shorthash_siphashx24_keybytes() == crypto_shorthash_siphashx24_KEYBYTES);
+
+    return 0;
+}

package/ios/libsodium-stable/test/default/siphashx24.exp

@@ -0,0 +1,64 @@
+a3817f04ba25a8e66df67214c7550293
+da87c1d86b99af44347659119b22fc45
+8177228da4a45dc7fca38bdef60affe4
+9c70b60c5267a94e5f33b6b02985ed51
+f88164c12d9c8faf7d0f6e7c7bcd5579
+1368875980776f8854527a07690e9627
+14eeca338b208613485ea0308fd7a15e
+a1f1ebbed8dbc153c0b84aa61ff08239
+3b62a9ba6258f5610f83e264f31497b4
+264499060ad9baabc47f8b02bb6d71ed
+00110dc378146956c95447d3f3d0fbba
+0151c568386b6677a2b4dc6f81e5dc18
+d626b266905ef35882634df68532c125
+9869e247e9c08b10d029934fc4b952f7
+31fcefac66d7de9c7ec7485fe4494902
+5493e99933b0a8117e08ec0f97cfc3d9
+6ee2a4ca67b054bbfd3315bf85230577
+473d06e8738db89854c066c47ae47740
+a426e5e423bf4885294da481feaef723
+78017731cf65fab074d5208952512eb1
+9e25fc833f2290733e9344a5e83839eb
+568e495abe525a218a2214cd3e071d12
+4a29b54552d16b9a469c10528eff0aae
+c9d184ddd5a9f5e0cf8ce29a9abf691c
+2db479ae78bd50d8882a8a178a6132ad
+8ece5f042d5e447b5051b9eacb8d8f6f
+9c0b53b4b3c307e87eaee08678141f66
+abf248af69a6eae4bfd3eb2f129eeb94
+0664da1668574b88b935f3027358aef4
+aa4b9dc4bf337de90cd4fd3c467c6ab7
+ea5c7f471faf6bde2b1ad7d4686d2287
+2939b0183223fafc1723de4f52c43d35
+7c3956ca5eeafc3e363e9d556546eb68
+77c6077146f01c32b6b69d5f4ea9ffcf
+37a6986cb8847edf0925f0f1309b54de
+a705f0e69da9a8f907241a2e923c8cc8
+3dc47d1f29c448461e9e76ed904f6711
+0d62bf01e6fc0e1a0d3c4751c5d3692b
+8c03468bca7c669ee4fd5e084bbee7b5
+528a5bb93baf2c9c4473cce5d0d22bd9
+df6a301e95c95dad97ae0cc8c6913bd8
+801189902c857f39e73591285e70b6db
+e617346ac9c231bb3650ae34ccca0c5b
+27d93437efb721aa401821dcec5adf89
+89237d9ded9c5e78d8b1c9b166cc7342
+4a6d8091bf5e7d651189fa94a250b14c
+0e33f96055e7ae893ffc0e3dcf492902
+e61c432b720b19d18ec8d84bdc63151b
+f7e5aef549f782cf379055a608269b16
+438d030fd0b7a54fa837f2ad201a6403
+a590d3ee4fbf04e3247e0d27f286423f
+5fe2c1a172fe93c4b15cd37caef9f538
+2c97325cbd06b36eb2133dd08b3a017c
+92c814227a6bca949ff0659f002ad39e
+dce850110bd8328cfbd50841d6911d87
+67f14984c7da791248e32bb5922583da
+1938f2cf72d54ee97e94166fa91d2a36
+74481e9646ed49fe0f6224301604698e
+57fca5de98a9d6d8006438d0583d8a1d
+9fecde1cefdc1cbed4763674d9575359
+e3040c00eb28f15366ca73cbd872e740
+7697009a6a831dfecca91c5993670f7a
+5853542321f567a005d547a4f04759bd
+5150d1772f50834a503e069a973fbd7c

package/ios/libsodium-stable/test/default/sodium_core.c

@@ -0,0 +1,43 @@
+
+#define TEST_NAME "sodium_core"
+#include "cmptest.h"
+
+static void
+misuse_handler(void)
+{
+    printf("misuse_handler()\n");
+    exit(0);
+}
+
+int
+main(void)
+{
+    sodium_set_misuse_handler(NULL);
+    sodium_set_misuse_handler(misuse_handler);
+    sodium_set_misuse_handler(NULL);
+
+    assert(sodium_init() == 1);
+
+    (void) sodium_runtime_has_neon();
+    (void) sodium_runtime_has_armcrypto();
+    (void) sodium_runtime_has_sse2();
+    (void) sodium_runtime_has_sse3();
+    (void) sodium_runtime_has_ssse3();
+    (void) sodium_runtime_has_sse41();
+    (void) sodium_runtime_has_avx();
+    (void) sodium_runtime_has_avx2();
+    (void) sodium_runtime_has_avx512f();
+    (void) sodium_runtime_has_pclmul();
+    (void) sodium_runtime_has_aesni();
+    (void) sodium_runtime_has_rdrand();
+
+    sodium_set_misuse_handler(misuse_handler);
+#if defined(__EMSCRIPTEN__) || defined(__wasm__) || defined(BENCHMARKS)
+    printf("misuse_handler()\n");
+#else
+    sodium_misuse();
+    printf("Misuse handler returned\n");
+#endif
+
+    return 0;
+}

package/ios/libsodium-stable/test/default/sodium_core.exp

@@ -0,0 +1 @@
+misuse_handler()

package/ios/libsodium-stable/test/default/sodium_utils.c

@@ -0,0 +1,224 @@
+#define TEST_NAME "sodium_utils"
+#include "cmptest.h"
+
+int
+main(void)
+{
+    unsigned char  buf_add[1000];
+    unsigned char  buf1[1000];
+    unsigned char  buf2[1000];
+    unsigned char  buf1_rev[1000];
+    unsigned char  buf2_rev[1000];
+    unsigned char  nonce[24];
+    char           nonce_hex[49];
+    unsigned char *bin_padded;
+    size_t         bin_len, bin_len2;
+    size_t         bin_padded_len;
+    size_t         bin_padded_maxlen;
+    size_t         blocksize;
+    unsigned int   i;
+    unsigned int   j;
+
+    randombytes_buf(buf1, sizeof buf1);
+    memcpy(buf2, buf1, sizeof buf2);
+    printf("%d\n", sodium_memcmp(buf1, buf2, sizeof buf1));
+    sodium_memzero(buf1, 0U);
+    printf("%d\n", sodium_memcmp(buf1, buf2, sizeof buf1));
+    sodium_memzero(buf1, sizeof buf1 / 2);
+    printf("%d\n", sodium_memcmp(buf1, buf2, sizeof buf1));
+    printf("%d\n", sodium_memcmp(buf1, buf2, 0U));
+    sodium_memzero(buf2, sizeof buf2 / 2);
+    printf("%d\n", sodium_memcmp(buf1, buf2, sizeof buf1));
+    printf("%d\n", sodium_memcmp(buf1, guard_page, 0U));
+    printf("%d\n", sodium_memcmp(guard_page, buf2, 0U));
+    printf("%d\n", sodium_memcmp(guard_page, guard_page, 0U));
+    sodium_memzero(guard_page, 0U);
+
+    memset(nonce, 0, sizeof nonce);
+    sodium_increment(nonce, sizeof nonce);
+    printf("%s\n",
+           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
+    memset(nonce, 255, sizeof nonce);
+    sodium_increment(nonce, sizeof nonce);
+    printf("%s\n",
+           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
+    nonce[1] = 1U;
+    sodium_increment(nonce, sizeof nonce);
+    printf("%s\n",
+           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
+    nonce[1] = 0U;
+    sodium_increment(nonce, sizeof nonce);
+    printf("%s\n",
+           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
+    nonce[0] = 255U;
+    nonce[2] = 255U;
+    sodium_increment(nonce, sizeof nonce);
+    printf("%s\n",
+           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
+    for (i = 0U; i < 1000U; i++) {
+        bin_len = (size_t) randombytes_uniform(sizeof buf1);
+        randombytes_buf(buf1, bin_len);
+        randombytes_buf(buf2, bin_len);
+        for (j = 0U; j < bin_len; j++) {
+            buf1_rev[bin_len - 1 - j] = buf1[j];
+            buf2_rev[bin_len - 1 - j] = buf2[j];
+        }
+        if (memcmp(buf1_rev, buf2_rev, bin_len) *
+            sodium_compare(buf1, buf2, bin_len) < 0) {
+            printf("sodium_compare() failure with length=%u\n",
+                   (unsigned int) bin_len);
+        }
+        memcpy(buf1, buf2, bin_len);
+        if (sodium_compare(buf1, buf2, bin_len)) {
+            printf("sodium_compare() equality failure with length=%u\n",
+                   (unsigned int) bin_len);
+        }
+    }
+    printf("%d\n", sodium_compare(buf1, NULL, 0U));
+    printf("%d\n", sodium_compare(NULL, buf1, 0U));
+    memset(buf1, 0, sizeof buf1);
+    if (sodium_is_zero(buf1, sizeof buf1) != 1) {
+        printf("sodium_is_zero() failed\n");
+    }
+    for (i = 0U; i < sizeof buf1; i++) {
+        buf1[i]++;
+        if (sodium_is_zero(buf1, sizeof buf1) != 0) {
+            printf("sodium_is_zero() failed\n");
+        }
+        buf1[i]--;
+    }
+    bin_len = randombytes_uniform(sizeof buf1);
+    randombytes_buf(buf1, bin_len);
+    memcpy(buf2, buf1, bin_len);
+    memset(buf_add, 0, bin_len);
+    j = randombytes_uniform(10000);
+    for (i = 0U; i < j; i++) {
+        sodium_increment(buf1, bin_len);
+        sodium_increment(buf_add, bin_len);
+    }
+    sodium_add(buf2, buf_add, bin_len);
+    if (sodium_compare(buf1, buf2, bin_len) != 0) {
+        printf("sodium_add() failed\n");
+    }
+    bin_len = randombytes_uniform(sizeof buf1);
+    randombytes_buf(buf1, bin_len);
+    memcpy(buf2, buf1, bin_len);
+    memset(buf_add, 0xff, bin_len);
+    sodium_increment(buf2, bin_len);
+    sodium_increment(buf2, 0U);
+    sodium_add(buf2, buf_add, bin_len);
+    sodium_add(buf2, buf_add, 0U);
+    if (sodium_compare(buf1, buf2, bin_len) != 0) {
+        printf("sodium_add() failed\n");
+    }
+    for (i = 0U; i < 1000U; i++) {
+        randombytes_buf(buf1, bin_len);
+        randombytes_buf(buf2, bin_len);
+        sodium_add(buf1, buf2, bin_len);
+        sodium_sub(buf1, buf2, bin_len);
+        sodium_sub(buf1, buf2, 0U);
+        if (sodium_is_zero(buf1, bin_len) &&
+            !sodium_is_zero(buf1, bin_len)) {
+            printf("sodium_sub() failed\n");
+        }
+        sodium_sub(buf1, buf1, bin_len);
+        if (!sodium_is_zero(buf1, bin_len)) {
+            printf("sodium_sub() failed\n");
+        }
+    }
+    assert(sizeof nonce >= 24U);
+    memset(nonce, 0xfe, 24U);
+    memset(nonce, 0xff, 6U);
+    sodium_increment(nonce, 8U);
+    printf("%s\n",
+           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
+    memset(nonce, 0xfe, 24U);
+    memset(nonce, 0xff, 10U);
+    sodium_increment(nonce, 12U);
+    printf("%s\n",
+           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
+    memset(nonce, 0xff, 22U);
+    sodium_increment(nonce, 24U);
+    printf("%s\n",
+           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
+
+    assert(sizeof nonce >= 24U);
+    memset(nonce, 0xfe, 24U);
+    memset(nonce, 0xff, 6U);
+    sodium_add(nonce, nonce, 7U);
+    sodium_add(nonce, nonce, 8U);
+    printf("%s\n",
+           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
+    memset(nonce, 0xfe, 24U);
+    memset(nonce, 0xff, 10U);
+    sodium_add(nonce, nonce, 11U);
+    sodium_add(nonce, nonce, 12U);
+    printf("%s\n",
+           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
+    memset(nonce, 0xff, 22U);
+    sodium_add(nonce, nonce, 23U);
+    sodium_add(nonce, nonce, 24U);
+    printf("%s\n",
+           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
+    sodium_add(nonce, nonce, 0U);
+    printf("%s\n",
+           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
+    sodium_add(nonce, guard_page, 0U);
+    printf("%s\n",
+           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
+    sodium_add(guard_page, nonce, 0U);
+
+    sodium_sub(nonce, nonce, 0U);
+    printf("%s\n",
+           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
+    sodium_sub(nonce, guard_page, 0U);
+    printf("%s\n",
+           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
+    sodium_sub(guard_page, nonce, 0U);
+
+    randombytes_buf(buf1, 64U);
+    randombytes_buf(buf2, 64U);
+    memset(buf_add, 0, 64U);
+    sodium_add(buf_add, buf1, 64U);
+    assert(!sodium_is_zero(buf_add, 64U));
+    sodium_add(buf_add, buf2, 64U);
+    assert(!sodium_is_zero(buf_add, 64U));
+    sodium_sub(buf_add, buf1, 64U);
+    assert(!sodium_is_zero(buf_add, 64U));
+    sodium_sub(buf_add, buf2, 64U);
+    assert(sodium_is_zero(buf_add, 64U));
+
+    for (i = 0; i < 2000U; i++) {
+        bin_len = randombytes_uniform(200U);
+        blocksize = 1U + randombytes_uniform(500U);
+        bin_padded_maxlen = bin_len + (blocksize - bin_len % blocksize);
+        bin_padded = (unsigned char *) sodium_malloc(bin_padded_maxlen);
+        randombytes_buf(bin_padded, bin_padded_maxlen);
+
+        assert(sodium_pad(&bin_padded_len, bin_padded, bin_len,
+                          blocksize, bin_padded_maxlen - 1U) == -1);
+        assert(sodium_pad(NULL, bin_padded, bin_len,
+                          blocksize, bin_padded_maxlen + 1U) == 0);
+        assert(sodium_pad(&bin_padded_len, bin_padded, bin_len,
+                          blocksize, bin_padded_maxlen + 1U) == 0);
+        assert(sodium_pad(&bin_padded_len, bin_padded, bin_len,
+                          0U, bin_padded_maxlen) == -1);
+        assert(sodium_pad(&bin_padded_len, bin_padded, bin_len,
+                          blocksize, bin_padded_maxlen) == 0);
+        assert(bin_padded_len == bin_padded_maxlen);
+
+        assert(sodium_unpad(&bin_len2, bin_padded, bin_padded_len,
+                            bin_padded_len + 1U) == -1);
+        assert(sodium_unpad(&bin_len2, bin_padded, bin_padded_len,
+                            0U) == -1);
+        assert(sodium_unpad(&bin_len2, bin_padded, bin_padded_len,
+                            blocksize) == 0);
+        assert(bin_len2 == bin_len);
+
+        sodium_free(bin_padded);
+    }
+
+    sodium_stackzero(512);
+
+    return 0;
+}

package/ios/libsodium-stable/test/default/sodium_utils.exp

@@ -0,0 +1,25 @@
+0
+0
+-1
+0
+0
+0
+0
+0
+010000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000
+010100000000000000000000000000000000000000000000
+020000000000000000000000000000000000000000000000
+0001ff000000000000000000000000000000000000000000
+0
+0
+000000000000fffefefefefefefefefefefefefefefefefe
+00000000000000000000fffefefefefefefefefefefefefe
+00000000000000000000000000000000000000000000fffe
+fcfffffffffffbfdfefefefefefefefefefefefefefefefe
+fcfffffffffffffffffffbfdfefefefefefefefefefefefe
+fcfffffffffffffffffffffffffffffffffffffffffffbfd
+fcfffffffffffffffffffffffffffffffffffffffffffbfd
+fcfffffffffffffffffffffffffffffffffffffffffffbfd
+fcfffffffffffffffffffffffffffffffffffffffffffbfd
+fcfffffffffffffffffffffffffffffffffffffffffffbfd

package/ios/libsodium-stable/test/default/sodium_utils2.c

@@ -0,0 +1,120 @@
+
+#include <stdlib.h>
+#include <sys/types.h>
+
+#include <limits.h>
+#ifdef HAVE_CATCHABLE_SEGV
+# include <signal.h>
+#endif
+#ifndef _WIN32
+# include <unistd.h>
+#endif
+
+#define TEST_NAME "sodium_utils2"
+#include "cmptest.h"
+
+#ifdef __SANITIZE_ADDRESS__
+# warning The sodium_utils2 test is expected to fail with address sanitizer
+#endif
+
+#undef sodium_malloc
+#undef sodium_free
+#undef sodium_allocarray
+
+__attribute__((noreturn)) static void
+segv_handler(int sig)
+{
+    (void) sig;
+
+    printf("Intentional segfault / bus error caught\n");
+    printf("OK\n");
+#ifdef SIG_DFL
+# ifdef SIGPROT
+    signal(SIGPROT, SIG_DFL);
+# endif
+# ifdef SIGSEGV
+    signal(SIGSEGV, SIG_DFL);
+# endif
+# ifdef SIGBUS
+    signal(SIGBUS, SIG_DFL);
+# endif
+# ifdef SIGABRT
+    signal(SIGABRT, SIG_DFL);
+# endif
+#endif
+    _exit(0);
+}
+
+int
+main(void)
+{
+    void         *buf;
+    size_t        size;
+    unsigned int  i;
+
+#ifdef BENCHMARKS
+    return 0;
+#endif
+
+    if (sodium_malloc(SIZE_MAX - 1U) != NULL) {
+        return 1;
+    }
+    if (sodium_malloc(0U) == NULL) {
+        return 1;
+    }
+    if (sodium_allocarray(SIZE_MAX / 2U + 1U, SIZE_MAX / 2U) != NULL) {
+        return 1;
+    }
+    sodium_free(sodium_allocarray(0U, 0U));
+    sodium_free(sodium_allocarray(0U, 1U));
+    sodium_free(sodium_allocarray(1U, 0U));
+
+    buf = sodium_allocarray(1000U, 50U);
+    memset(buf, 0, 50000U);
+    sodium_free(buf);
+
+    sodium_free(sodium_malloc(0U));
+    sodium_free(NULL);
+    for (i = 0U; i < 10000U; i++) {
+        size = 1U + randombytes_uniform(100000U);
+        buf  = sodium_malloc(size);
+        assert(buf != NULL);
+        memset(buf, i, size);
+        sodium_mprotect_noaccess(buf);
+        sodium_free(buf);
+    }
+    printf("OK\n");
+#ifdef SIG_DFL
+# ifdef SIGPROT
+    signal(SIGPROT, segv_handler);
+# endif
+# ifdef SIGSEGV
+    signal(SIGSEGV, segv_handler);
+# endif
+# ifdef SIGBUS
+    signal(SIGBUS, segv_handler);
+# endif
+# ifdef SIGABRT
+    signal(SIGABRT, segv_handler);
+# endif
+#endif
+    size = 1U + randombytes_uniform(100000U);
+    buf  = sodium_malloc(size);
+    assert(buf != NULL);
+
+/* old versions of asan emit a warning because they don't support mlock*() */
+#ifndef __SANITIZE_ADDRESS__
+    sodium_mprotect_readonly(buf);
+    sodium_mprotect_readwrite(buf);
+#endif
+
+#if defined(HAVE_CATCHABLE_SEGV) && !defined(__EMSCRIPTEN__) && !defined(__SANITIZE_ADDRESS__)
+    sodium_memzero(((unsigned char *) buf) + size, 1U);
+    sodium_mprotect_noaccess(buf);
+    sodium_free(buf);
+    printf("Overflow not caught\n");
+#else
+    segv_handler(0);
+#endif
+    return 0;
+}

package/ios/libsodium-stable/test/default/sodium_utils2.exp

@@ -0,0 +1,3 @@
+OK
+Intentional segfault / bus error caught
+OK

package/ios/libsodium-stable/test/default/sodium_utils3.c

@@ -0,0 +1,90 @@
+
+#include <stdlib.h>
+#include <sys/types.h>
+
+#include <limits.h>
+#ifdef HAVE_CATCHABLE_SEGV
+# include <signal.h>
+#endif
+#ifndef _WIN32
+# include <unistd.h>
+#endif
+
+#define TEST_NAME "sodium_utils3"
+#include "cmptest.h"
+
+#ifdef __SANITIZE_ADDRESS__
+# warning The sodium_utils3 test is expected to fail with address sanitizer
+#endif
+#ifdef __SANITIZE_THREAD__
+# warning The sodium_utils3 test is expected to fail with thread sanitizer
+#endif
+
+__attribute__((noreturn)) static void
+segv_handler(int sig)
+{
+    (void) sig;
+
+    printf("Intentional segfault / bus error caught\n");
+    printf("OK\n");
+#ifdef SIG_DFL
+# ifdef SIGPROT
+    signal(SIGPROT, SIG_DFL);
+# endif
+# ifdef SIGSEGV
+    signal(SIGSEGV, SIG_DFL);
+# endif
+# ifdef SIGBUS
+    signal(SIGBUS, SIG_DFL);
+# endif
+# ifdef SIGABRT
+    signal(SIGABRT, SIG_DFL);
+# endif
+#endif
+    _exit(0);
+}
+
+int
+main(void)
+{
+    void * buf;
+    size_t size;
+
+#ifdef BENCHMARKS
+    return 0;
+#endif
+
+#ifdef SIG_DFL
+# ifdef SIGPROT
+    signal(SIGPROT, segv_handler);
+# endif
+# ifdef SIGSEGV
+    signal(SIGSEGV, segv_handler);
+# endif
+# ifdef SIGBUS
+    signal(SIGBUS, segv_handler);
+# endif
+# ifdef SIGABRT
+    signal(SIGABRT, segv_handler);
+# endif
+#endif
+    size = 1U + randombytes_uniform(100000U);
+    buf  = sodium_malloc(size);
+    assert(buf != NULL);
+
+/* old versions of asan emit a warning because they don't support mlock*() */
+#ifndef __SANITIZE_ADDRESS__
+    sodium_mprotect_noaccess(buf);
+    sodium_mprotect_readwrite(buf);
+#endif
+
+#if defined(HAVE_CATCHABLE_SEGV) && !defined(__EMSCRIPTEN__) && !defined(__SANITIZE_ADDRESS__) && !defined(__SANITIZE_THREAD__)
+    sodium_memzero(((unsigned char *) buf) - 8, 8U);
+    sodium_mprotect_readonly(buf);
+    sodium_free(buf);
+    printf("Underflow not caught\n");
+#else
+    segv_handler(0);
+#endif
+    return 0;
+}

package/ios/libsodium-stable/test/default/sodium_utils3.exp

@@ -0,0 +1,2 @@
+Intentional segfault / bus error caught
+OK

package/ios/libsodium-stable/test/default/sodium_version.c

@@ -0,0 +1,18 @@
+
+#define TEST_NAME "sodium_version"
+#include "cmptest.h"
+
+int
+main(void)
+{
+    printf("%d\n", sodium_version_string() != NULL);
+    printf("%d\n", sodium_library_version_major() > 0);
+    printf("%d\n", sodium_library_version_minor() >= 0);
+#ifdef SODIUM_LIBRARY_MINIMAL
+    assert(sodium_library_minimal() == 1);
+#else
+    assert(sodium_library_minimal() == 0);
+#endif
+
+    return 0;
+}

package/ios/libsodium-stable/test/default/sodium_version.exp

@@ -0,0 +1,3 @@
+1
+1
+1