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

package/ios/libsodium-stable/test/default/cmptest.h

@@ -0,0 +1,238 @@
+
+#ifndef __CMPTEST_H__
+#define __CMPTEST_H__
+
+#ifdef NDEBUG
+#/**/undef/**/ NDEBUG
+#endif
+
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "sodium.h"
+#include "quirks.h"
+
+#ifdef __EMSCRIPTEN__
+# undef TEST_SRCDIR
+# define TEST_SRCDIR "/test-data"
+#endif
+#ifndef TEST_SRCDIR
+# define TEST_SRCDIR "."
+#endif
+
+#define TEST_NAME_RES TEST_NAME ".res"
+#define TEST_NAME_OUT TEST_SRCDIR "/" TEST_NAME ".exp"
+
+#ifdef HAVE_ARC4RANDOM
+# undef rand
+# define rand(X) arc4random(X)
+#endif
+
+int xmain(void);
+
+static unsigned char *guard_page;
+
+#ifdef BENCHMARKS
+
+# include <sys/time.h>
+
+# ifndef ITERATIONS
+#  define ITERATIONS 128
+# endif
+
+struct {
+    void   *pnt;
+    size_t  size;
+} mempool[1024];
+
+static size_t mempool_idx;
+
+static __attribute__((malloc)) void *mempool_alloc(size_t size)
+{
+    size_t i;
+    if (size >= (size_t) 0x80000000 - (size_t) 0x00000fff) {
+        return NULL;
+    }
+    size = (size + (size_t) 0x00000fff) & ~ (size_t) 0x00000fff;
+    for (i = 0U; i < mempool_idx; i++) {
+        if (mempool[i].size >= (size | (size_t) 0x80000000)) {
+            mempool[i].size &= ~ (size_t) 0x80000000;
+            return mempool[i].pnt;
+        }
+    }
+    if (mempool_idx >= sizeof mempool / sizeof mempool[0]) {
+        return NULL;
+    }
+    mempool[mempool_idx].size = size;
+    return (mempool[mempool_idx++].pnt = (void *) malloc(size));
+}
+
+static void mempool_free(void *pnt)
+{
+    size_t i;
+    for (i = 0U; i < mempool_idx; i++) {
+        if (mempool[i].pnt == pnt) {
+            if ((mempool[i].size & (size_t) 0x80000000) != (size_t) 0x0) {
+                break;
+            }
+            mempool[i].size |= (size_t) 0x80000000;
+            return;
+        }
+    }
+    abort();
+}
+
+static __attribute__((malloc)) void *mempool_allocarray(size_t count, size_t size)
+{
+    if (count > (size_t) 0U && size >= (size_t) SIZE_MAX / count) {
+        return NULL;
+    }
+    return mempool_alloc(count * size);
+}
+
+static int mempool_free_all(void)
+{
+    size_t i;
+    int    ret = 0;
+
+    for (i = 0U; i < mempool_idx; i++) {
+        if ((mempool[i].size & (size_t) 0x80000000) == (size_t) 0x0) {
+            ret = -1;
+        }
+        free(mempool[i].pnt);
+        mempool[i].pnt = NULL;
+    }
+    mempool_idx = (size_t) 0U;
+
+    return ret;
+}
+
+#define sodium_malloc(X)        mempool_alloc(X)
+#define sodium_free(X)          mempool_free(X)
+#define sodium_allocarray(X, Y) mempool_allocarray((X), (Y))
+
+static unsigned long long now(void)
+{
+#if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)
+    struct timespec tp;
+
+    if (clock_gettime(CLOCK_MONOTONIC, &tp) != 0) {
+        abort();
+    }
+    return (unsigned long long) tp.tv_sec * 1000000ULL +
+        (unsigned long long) tp.tv_nsec / 1000ULL;
+#else
+    struct timeval tp;
+
+    if (gettimeofday(&tp, NULL) != 0) {
+        abort();
+    }
+    return (unsigned long long) tp.tv_sec * 1000000ULL +
+        (unsigned long long) tp.tv_usec;
+#endif
+}
+
+int main(void)
+{
+    unsigned long long ts_start;
+    unsigned long long ts_end;
+    unsigned int       i;
+
+    if (sodium_init() != 0) {
+        return 99;
+    }
+
+#ifndef __EMSCRIPTEN__
+    randombytes_set_implementation(&randombytes_salsa20_implementation);
+#endif
+    ts_start = now();
+    for (i = 0; i < ITERATIONS; i++) {
+        if (xmain() != 0) {
+            abort();
+        }
+    }
+    ts_end = now();
+    printf("%llu\n", 1000000ULL * (ts_end - ts_start) / ITERATIONS);
+    if (mempool_free_all() != 0) {
+        fprintf(stderr, "** memory leaks detected **\n");
+        return 99;
+    }
+    return 0;
+}
+
+#undef  printf
+#define printf(...) do { } while(0)
+
+#elif !defined(BROWSER_TESTS)
+
+static FILE *fp_res;
+
+int main(void)
+{
+    FILE          *fp_out;
+    unsigned char *_guard_page;
+    int           c;
+
+    if ((fp_res = fopen(TEST_NAME_RES, "w+")) == NULL) {
+        perror("fopen(" TEST_NAME_RES ")");
+        return 99;
+    }
+    if (sodium_init() != 0) {
+        return 99;
+    }
+# if defined(__EMSCRIPTEN__) || defined(__SANITIZE_ADDRESS__)
+    guard_page = _guard_page = NULL;
+#else
+    if ((_guard_page = (unsigned char *) sodium_malloc(0)) == NULL) {
+        perror("sodium_malloc()");
+        return 99;
+    }
+    guard_page = _guard_page + 1;
+#endif
+    if (xmain() != 0) {
+        return 99;
+    }
+    fflush(fp_res);
+    rewind(fp_res);
+    if ((fp_out = fopen(TEST_NAME_OUT, "r")) == NULL) {
+        perror("fopen(" TEST_NAME_OUT ")");
+        return 99;
+    }
+    do {
+        if ((c = fgetc(fp_res)) != fgetc(fp_out)) {
+            return 99;
+        }
+    } while (c != EOF);
+    sodium_free(_guard_page);
+
+    return 0;
+}
+
+#undef  printf
+#define printf(...) fprintf(fp_res, __VA_ARGS__)
+
+#else
+
+int main(void)
+{
+    if (sodium_init() != 0) {
+        return 99;
+    }
+    if (xmain() != 0) {
+        return 99;
+    }
+    printf("--- SUCCESS ---\n");
+
+    return 0;
+}
+
+#endif
+
+#define main xmain
+
+#endif

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

@@ -0,0 +1,251 @@
+#define TEST_NAME "codecs"
+#include "cmptest.h"
+
+int
+main(void)
+{
+    unsigned char  buf1[1000];
+    char           buf3[33];
+    unsigned char  buf4[4];
+    const char    *b64;
+    char          *b64_;
+    const char    *b64_end;
+    unsigned char *bin;
+    const char    *hex;
+    const char    *hex_end;
+    size_t         b64_len;
+    size_t         bin_len;
+    unsigned int   i;
+
+    printf("%s\n",
+           sodium_bin2hex(buf3, 33U, (const unsigned char *) "0123456789ABCDEF",
+                          16U));
+    printf("bin2hex(..., guard_page, 0):%s\n",
+           sodium_bin2hex(buf3, sizeof buf3, guard_page, 0U));
+    printf("bin2hex(..., \"\", 0):%s\n",
+           sodium_bin2hex(buf3, sizeof buf3, (const unsigned char *) "", 0U));
+
+    hex = "Cafe : 6942";
+    sodium_hex2bin(buf4, sizeof buf4, hex, strlen(hex), ": ", &bin_len,
+                   &hex_end);
+    printf("%lu:%02x%02x%02x%02x\n", (unsigned long) bin_len,
+           buf4[0], buf4[1], buf4[2], buf4[3]);
+    printf("dt1: %ld\n", (long) (hex_end - hex));
+
+    hex = "Cafe : 6942";
+    sodium_hex2bin(buf4, sizeof buf4, hex, strlen(hex), ": ", &bin_len, NULL);
+    printf("%lu:%02x%02x%02x%02x\n", (unsigned long) bin_len,
+           buf4[0], buf4[1], buf4[2], buf4[3]);
+
+    hex = "deadbeef";
+    if (sodium_hex2bin(buf1, 1U, hex, 8U, NULL, &bin_len, &hex_end) != -1) {
+        printf("sodium_hex2bin() overflow not detected\n");
+    }
+    printf("dt2: %ld\n", (long) (hex_end - hex));
+
+    hex = "de:ad:be:eff";
+    if (sodium_hex2bin(buf1, 4U, hex, 12U, ":", &bin_len, &hex_end) != -1) {
+        printf(
+            "sodium_hex2bin() with an odd input length and a short output "
+            "buffer\n");
+    }
+    printf("dt3: %ld\n", (long) (hex_end - hex));
+
+    hex = "de:ad:be:eff";
+    if (sodium_hex2bin(buf1, sizeof buf1, hex, 12U, ":",
+                       &bin_len, &hex_end) != -1) {
+        printf("sodium_hex2bin() with an odd input length\n");
+    }
+    printf("dt4: %ld\n", (long) (hex_end - hex));
+
+    hex = "de:ad:be:eff";
+    if (sodium_hex2bin(buf1, sizeof buf1, hex, 13U, ":",
+                       &bin_len, &hex_end) != -1) {
+        printf("sodium_hex2bin() with an odd input length (2)\n");
+    }
+    printf("dt5: %ld\n", (long) (hex_end - hex));
+
+    hex = "de:ad:be:eff";
+    if (sodium_hex2bin(buf1, sizeof buf1, hex, 12U, ":",
+                       &bin_len, NULL) != -1) {
+        printf("sodium_hex2bin() with an odd input length and no end pointer\n");
+    }
+
+    hex = "de:ad:be:ef*";
+    if (sodium_hex2bin(buf1, sizeof buf1, hex, 12U, ":",
+                       &bin_len, &hex_end) != 0) {
+        printf("sodium_hex2bin() with an extra character and an end pointer\n");
+    }
+    printf("dt6: %ld\n", (long) (hex_end - hex));
+
+    hex = "de:ad:be:ef*";
+    if (sodium_hex2bin(buf1, sizeof buf1, hex, 12U, ":",
+                       &bin_len, NULL) != -1) {
+        printf("sodium_hex2bin() with an extra character and no end pointer\n");
+    }
+
+    assert(sodium_hex2bin(buf4, sizeof buf4, (const char *) guard_page, 0U,
+                          NULL, &bin_len, NULL) == 0);
+    assert(bin_len == 0);
+
+    assert(sodium_hex2bin(buf4, sizeof buf4, "", 0U, NULL, &bin_len, NULL) == 0);
+    assert(bin_len == 0);
+
+    printf("%s\n",
+           sodium_bin2base64(buf3, 31U, (const unsigned char *) "\xfb\xf0\xf1" "0123456789ABCDEFab",
+                             21U, sodium_base64_VARIANT_ORIGINAL));
+    printf("%s\n",
+           sodium_bin2base64(buf3, 33U, (const unsigned char *) "\xfb\xf0\xf1" "0123456789ABCDEFabc",
+                             22U, sodium_base64_VARIANT_ORIGINAL_NO_PADDING));
+    printf("%s\n",
+           sodium_bin2base64(buf3, 31U, (const unsigned char *) "\xfb\xf0\xf1" "0123456789ABCDEFab",
+                             21U, sodium_base64_VARIANT_URLSAFE));
+    printf("%s\n",
+           sodium_bin2base64(buf3, 33U, (const unsigned char *) "\xfb\xf0\xf1" "0123456789ABCDEFabc",
+                             22U, sodium_base64_VARIANT_URLSAFE_NO_PADDING));
+    printf("%s\n",
+           sodium_bin2base64(buf3, 1U, guard_page,
+                             0U, sodium_base64_VARIANT_ORIGINAL));
+    printf("%s\n",
+           sodium_bin2base64(buf3, 5U, (const unsigned char *) "a",
+                             1U, sodium_base64_VARIANT_ORIGINAL));
+    printf("%s\n",
+           sodium_bin2base64(buf3, 5U, (const unsigned char *) "ab",
+                             2U, sodium_base64_VARIANT_ORIGINAL));
+    printf("%s\n",
+           sodium_bin2base64(buf3, 5U, (const unsigned char *) "abc",
+                             3U, sodium_base64_VARIANT_ORIGINAL));
+    printf("%s\n",
+           sodium_bin2base64(buf3, 1U, guard_page,
+                             0U, sodium_base64_VARIANT_ORIGINAL_NO_PADDING));
+    printf("%s\n",
+           sodium_bin2base64(buf3, 3U, (const unsigned char *) "a",
+                             1U, sodium_base64_VARIANT_ORIGINAL_NO_PADDING));
+    printf("%s\n",
+           sodium_bin2base64(buf3, 4U, (const unsigned char *) "ab",
+                             2U, sodium_base64_VARIANT_ORIGINAL_NO_PADDING));
+    printf("%s\n",
+           sodium_bin2base64(buf3, 5U, (const unsigned char *) "abc",
+                             3U, sodium_base64_VARIANT_ORIGINAL_NO_PADDING));
+
+    b64 = "VGhpcyBpcyBhIGpvdXJu" "\n" "ZXkgaW50by" " " "Bzb3VuZA==";
+    memset(buf4, '*', sizeof buf4);
+    assert(sodium_base642bin(buf4, sizeof buf4, b64, strlen(b64), "\n\r ", &bin_len,
+                             &b64_end, sodium_base64_VARIANT_ORIGINAL) == -1);
+    buf4[bin_len] = 0;
+    printf("[%s]\n", (const char *) buf4);
+    printf("[%s]\n", b64_end);
+
+    memset(buf1, '*', sizeof buf1);
+    assert(sodium_base642bin(buf1, sizeof buf1, b64, strlen(b64), "\n\r ", &bin_len,
+                             &b64_end, sodium_base64_VARIANT_ORIGINAL) == 0);
+    buf1[bin_len] = 0;
+    printf("[%s]\n", (const char *) buf1);
+    assert(*b64_end == 0);
+
+    memset(buf1, '*', sizeof buf1);
+    assert(sodium_base642bin(buf1, sizeof buf1, b64, strlen(b64), NULL, &bin_len,
+                             &b64_end, sodium_base64_VARIANT_ORIGINAL) == 0);
+    buf1[bin_len] = 0;
+    printf("[%s]\n", (const char *) buf1);
+    printf("[%s]\n", b64_end);
+
+    assert(sodium_base642bin(buf1, sizeof buf1, b64, strlen(b64), NULL, NULL,
+                             &b64_end, sodium_base64_VARIANT_ORIGINAL) == 0);
+    assert(sodium_base642bin(buf1, sizeof buf1, b64, strlen(b64), NULL, NULL,
+                             &b64_end, sodium_base64_VARIANT_ORIGINAL_NO_PADDING) == 0);
+    assert(sodium_base642bin(buf1, sizeof buf1, b64, strlen(b64), " \r\n", NULL,
+                             &b64_end, sodium_base64_VARIANT_ORIGINAL_NO_PADDING) == 0);
+    assert(sodium_base642bin(buf1, sizeof buf1, b64, strlen(b64), NULL, NULL,
+                             &b64_end, sodium_base64_VARIANT_URLSAFE_NO_PADDING) == 0);
+    assert(sodium_base642bin(buf1, sizeof buf1, b64, strlen(b64), " \r\n", NULL,
+                             &b64_end, sodium_base64_VARIANT_URLSAFE_NO_PADDING) == 0);
+
+    assert(sodium_base642bin(buf1, sizeof buf1, b64, strlen(b64), NULL, NULL,
+                             NULL, sodium_base64_VARIANT_ORIGINAL) == -1);
+    assert(sodium_base642bin(buf1, sizeof buf1, b64, strlen(b64), NULL, NULL,
+                             NULL, sodium_base64_VARIANT_ORIGINAL_NO_PADDING) == -1);
+    assert(sodium_base642bin(buf1, sizeof buf1, b64, strlen(b64), " \r\n", NULL,
+                             NULL, sodium_base64_VARIANT_ORIGINAL_NO_PADDING) == -1);
+    assert(sodium_base642bin(buf1, sizeof buf1, b64, strlen(b64), NULL, NULL,
+                             NULL, sodium_base64_VARIANT_URLSAFE_NO_PADDING) == -1);
+    assert(sodium_base642bin(buf1, sizeof buf1, b64, strlen(b64), " \r\n", NULL,
+                             NULL, sodium_base64_VARIANT_URLSAFE_NO_PADDING) == -1);
+
+    assert(sodium_base642bin(guard_page, (size_t) 10U, "a=", (size_t) 2U, NULL, NULL, NULL,
+                             sodium_base64_VARIANT_URLSAFE) == -1);
+    assert(sodium_base642bin(guard_page, (size_t) 10U, "a*", (size_t) 2U, NULL, NULL, NULL,
+                             sodium_base64_VARIANT_URLSAFE) == -1);
+    assert(sodium_base642bin(guard_page, (size_t) 10U, "a*", (size_t) 2U, "~", NULL, NULL,
+                             sodium_base64_VARIANT_URLSAFE) == -1);
+    assert(sodium_base642bin(guard_page, (size_t) 10U, "a*", (size_t) 2U, "*", NULL, NULL,
+                             sodium_base64_VARIANT_URLSAFE) == -1);
+    assert(sodium_base642bin(guard_page, (size_t) 10U, "a==", (size_t) 3U, NULL, NULL, NULL,
+                             sodium_base64_VARIANT_URLSAFE) == -1);
+    assert(sodium_base642bin(guard_page, (size_t) 10U, "a=*", (size_t) 3U, NULL, NULL, NULL,
+                             sodium_base64_VARIANT_URLSAFE) == -1);
+    assert(sodium_base642bin(guard_page, (size_t) 10U, "a=*", (size_t) 3U, "~", NULL, NULL,
+                             sodium_base64_VARIANT_URLSAFE) == -1);
+    assert(sodium_base642bin(guard_page, (size_t) 10U, "a=*", (size_t) 3U, "*", NULL, NULL,
+                             sodium_base64_VARIANT_URLSAFE) == -1);
+
+    assert(sodium_base642bin(buf1, sizeof buf1, "O1R", (size_t) 3U, NULL, NULL, NULL,
+                             sodium_base64_VARIANT_ORIGINAL_NO_PADDING) == -1);
+    assert(sodium_base642bin(buf1, sizeof buf1, "O1Q", (size_t) 3U, NULL, NULL, NULL,
+                             sodium_base64_VARIANT_ORIGINAL_NO_PADDING) == 0);
+    assert(sodium_base642bin(buf1, sizeof buf1, "O1", (size_t) 2U, NULL, NULL, NULL,
+                             sodium_base64_VARIANT_ORIGINAL_NO_PADDING) == -1);
+    assert(sodium_base642bin(buf1, sizeof buf1, "Ow", (size_t) 2U, NULL, NULL, NULL,
+                             sodium_base64_VARIANT_ORIGINAL_NO_PADDING) == 0);
+    assert(sodium_base642bin(buf1, sizeof buf1, "O", (size_t) 1U, NULL, NULL, NULL,
+                             sodium_base64_VARIANT_ORIGINAL_NO_PADDING) == -1);
+
+    assert(sodium_base642bin(buf1, sizeof buf1, "", (size_t) 0U, NULL, NULL, NULL,
+                             sodium_base64_VARIANT_ORIGINAL) == 0);
+    assert(sodium_base642bin(buf1, sizeof buf1, "A", (size_t) 1U, NULL, NULL, NULL,
+                             sodium_base64_VARIANT_ORIGINAL) == -1);
+    assert(sodium_base642bin(buf1, sizeof buf1, "AA", (size_t) 2U, NULL, NULL, NULL,
+                             sodium_base64_VARIANT_ORIGINAL) == -1);
+    assert(sodium_base642bin(buf1, sizeof buf1, "kaw", (size_t) 3U, NULL, NULL, NULL,
+                             sodium_base64_VARIANT_ORIGINAL) == -1);
+    assert(sodium_base642bin(buf1, sizeof buf1, "kQ*", (size_t) 3U, "@", NULL, NULL,
+                             sodium_base64_VARIANT_ORIGINAL) == -1);
+    assert(sodium_base642bin(buf1, sizeof buf1, "kQ*", (size_t) 3U, "*", NULL, NULL,
+                             sodium_base64_VARIANT_ORIGINAL) == -1);
+    assert(sodium_base642bin(buf1, sizeof buf1, "kaw=**", (size_t) 6U, "*", NULL, NULL,
+                             sodium_base64_VARIANT_ORIGINAL) == 0);
+    assert(sodium_base642bin(buf1, sizeof buf1, "kaw*=*", (size_t) 6U, "~*", NULL, NULL,
+                             sodium_base64_VARIANT_ORIGINAL) == 0);
+    assert(sodium_base642bin(buf1, sizeof buf1, "ka*w*=*", (size_t) 7U, "*~", NULL, NULL,
+                             sodium_base64_VARIANT_ORIGINAL) == 0);
+
+    assert(sodium_base642bin(buf1, sizeof buf1, (const char *) guard_page, 0U,
+                             NULL, &bin_len, NULL, sodium_base64_VARIANT_ORIGINAL) == 0);
+    assert(bin_len == 0);
+
+    assert(sodium_base642bin(buf1, sizeof buf1, "", 0U, NULL, &bin_len, NULL,
+                             sodium_base64_VARIANT_ORIGINAL) == 0);
+    assert(bin_len == 0);
+
+    for (i = 0; i < 1000; i++) {
+        assert(sizeof buf1 >= 100);
+        bin_len = (size_t) randombytes_uniform(100);
+        bin = (unsigned char *) sodium_malloc(bin_len);
+        b64_len = (bin_len + 2U) / 3U * 4U + 1U;
+        assert(b64_len == sodium_base64_encoded_len(bin_len, sodium_base64_VARIANT_URLSAFE));
+        b64_ = (char *) sodium_malloc(b64_len);
+        randombytes_buf(bin, bin_len);
+        memcpy(buf1, bin, bin_len);
+        b64 = sodium_bin2base64(b64_, b64_len, bin, bin_len,
+                                sodium_base64_VARIANT_URLSAFE);
+        assert(b64 != NULL);
+        assert(sodium_base642bin(bin, bin_len + 10, b64, b64_len,
+                                 NULL, NULL, &b64_end,
+                                 sodium_base64_VARIANT_URLSAFE) == 0);
+        assert(b64_end == &b64[b64_len - 1]);
+        assert(memcmp(bin, buf1, bin_len) == 0);
+        sodium_free(bin);
+        sodium_free(b64_);
+    }
+    return 0;
+}

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

@@ -0,0 +1,30 @@
+30313233343536373839414243444546
+bin2hex(..., guard_page, 0):
+bin2hex(..., "", 0):
+4:cafe6942
+dt1: 11
+4:cafe6942
+dt2: 2
+dt3: 11
+dt4: 11
+dt5: 11
+dt6: 11
++/DxMDEyMzQ1Njc4OUFCQ0RFRmFi
++/DxMDEyMzQ1Njc4OUFCQ0RFRmFiYw
+-_DxMDEyMzQ1Njc4OUFCQ0RFRmFi
+-_DxMDEyMzQ1Njc4OUFCQ0RFRmFiYw
+
+YQ==
+YWI=
+YWJj
+
+YQ
+YWI
+YWJj
+[]
+[BpcyBhIGpvdXJu
+ZXkgaW50by Bzb3VuZA==]
+[This is a journey into sound]
+[This is a journ]
+[
+ZXkgaW50by Bzb3VuZA==]

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

@@ -0,0 +1,41 @@
+
+#define TEST_NAME "core1"
+#include "cmptest.h"
+
+static unsigned char shared[32] = { 0x4a, 0x5d, 0x9d, 0x5b, 0xa4, 0xce, 0x2d,
+                                    0xe1, 0x72, 0x8e, 0x3b, 0xf4, 0x80, 0x35,
+                                    0x0f, 0x25, 0xe0, 0x7e, 0x21, 0xc9, 0x47,
+                                    0xd1, 0x9e, 0x33, 0x76, 0xf0, 0x9b, 0x3c,
+                                    0x1e, 0x16, 0x17, 0x42 };
+
+static unsigned char zero[32];
+
+static unsigned char c[16] = { 0x65, 0x78, 0x70, 0x61, 0x6e, 0x64, 0x20, 0x33,
+                               0x32, 0x2d, 0x62, 0x79, 0x74, 0x65, 0x20, 0x6b };
+
+static unsigned char firstkey[32];
+
+int
+main(void)
+{
+    int i;
+
+    crypto_core_hsalsa20(firstkey, zero, shared, c);
+    for (i = 0; i < 32; ++i) {
+        if (i > 0) {
+            printf(",");
+        } else {
+            printf(" ");
+        }
+        printf("0x%02x", (unsigned int) firstkey[i]);
+        if (i % 8 == 7) {
+            printf("\n");
+        }
+    }
+    assert(crypto_core_hsalsa20_outputbytes() > 0U);
+    assert(crypto_core_hsalsa20_inputbytes() > 0U);
+    assert(crypto_core_hsalsa20_keybytes() > 0U);
+    assert(crypto_core_hsalsa20_constbytes() > 0U);
+
+    return 0;
+}

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

@@ -0,0 +1,4 @@
+ 0x1b,0x27,0x55,0x64,0x73,0xe9,0x85,0xd4
+,0x62,0xcd,0x51,0x19,0x7a,0x9a,0x46,0xc7
+,0x60,0x09,0x54,0x9e,0xac,0x64,0x74,0xf2
+,0x06,0xc4,0xee,0x08,0x44,0xf6,0x83,0x89

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

@@ -0,0 +1,38 @@
+
+#define TEST_NAME "core2"
+#include "cmptest.h"
+
+static unsigned char firstkey[32] = { 0x1b, 0x27, 0x55, 0x64, 0x73, 0xe9, 0x85,
+                                      0xd4, 0x62, 0xcd, 0x51, 0x19, 0x7a, 0x9a,
+                                      0x46, 0xc7, 0x60, 0x09, 0x54, 0x9e, 0xac,
+                                      0x64, 0x74, 0xf2, 0x06, 0xc4, 0xee, 0x08,
+                                      0x44, 0xf6, 0x83, 0x89 };
+
+static unsigned char nonceprefix[16] = { 0x69, 0x69, 0x6e, 0xe9, 0x55, 0xb6,
+                                         0x2b, 0x73, 0xcd, 0x62, 0xbd, 0xa8,
+                                         0x75, 0xfc, 0x73, 0xd6 };
+
+static unsigned char c[16] = { 0x65, 0x78, 0x70, 0x61, 0x6e, 0x64, 0x20, 0x33,
+                               0x32, 0x2d, 0x62, 0x79, 0x74, 0x65, 0x20, 0x6b };
+
+static unsigned char secondkey[32];
+
+int
+main(void)
+{
+    int i;
+
+    crypto_core_hsalsa20(secondkey, nonceprefix, firstkey, c);
+    for (i = 0; i < 32; ++i) {
+        if (i > 0) {
+            printf(",");
+        } else {
+            printf(" ");
+        }
+        printf("0x%02x", (unsigned int) secondkey[i]);
+        if (i % 8 == 7) {
+            printf("\n");
+        }
+    }
+    return 0;
+}

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

@@ -0,0 +1,4 @@
+ 0xdc,0x90,0x8d,0xda,0x0b,0x93,0x44,0xa9
+,0x53,0x62,0x9b,0x73,0x38,0x20,0x77,0x88
+,0x80,0xf3,0xce,0xb4,0x21,0xbb,0x61,0xb9
+,0x1c,0xbd,0x4c,0x3e,0x66,0x25,0x6c,0xe4