react-native-quick-crypto 1.0.0-beta.20 → 1.0.0-beta.21

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

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

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

@@ -1,33 +0,0 @@
-
-#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

@@ -1,64 +0,0 @@
-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

@@ -1,43 +0,0 @@
-
-#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

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

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

@@ -1,224 +0,0 @@
-#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

@@ -1,25 +0,0 @@
-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

@@ -1,120 +0,0 @@
-
-#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

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

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

@@ -1,90 +0,0 @@
-
-#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

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

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

@@ -1,18 +0,0 @@
-
-#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

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