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

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

@@ -0,0 +1,72 @@
+
+#define TEST_NAME "secretbox_easy2"
+#include "cmptest.h"
+
+int
+main(void)
+{
+    unsigned char *m;
+    unsigned char *m2;
+    unsigned char *c;
+    unsigned char *nonce;
+    unsigned char *k;
+    unsigned char *mac;
+    size_t         mlen;
+    size_t         i;
+
+    mlen  = (size_t) randombytes_uniform((uint32_t) 10000) + 1U;
+    m     = (unsigned char *) sodium_malloc(mlen);
+    m2    = (unsigned char *) sodium_malloc(mlen);
+    c     = (unsigned char *) sodium_malloc(crypto_secretbox_MACBYTES + mlen);
+    nonce = (unsigned char *) sodium_malloc(crypto_secretbox_NONCEBYTES);
+    k     = (unsigned char *) sodium_malloc(crypto_secretbox_KEYBYTES);
+    mac   = (unsigned char *) sodium_malloc(crypto_secretbox_MACBYTES);
+    crypto_secretbox_keygen(k);
+    randombytes_buf(m, mlen);
+    randombytes_buf(nonce, crypto_secretbox_NONCEBYTES);
+    crypto_secretbox_easy(c, m, (unsigned long long) mlen, nonce, k);
+    if (crypto_secretbox_open_easy(
+            m2, c, (unsigned long long) mlen + crypto_secretbox_MACBYTES, nonce,
+            k) != 0) {
+        printf("crypto_secretbox_open_easy() failed\n");
+    }
+    printf("%d\n", memcmp(m, m2, mlen));
+
+    for (i = 0; i < mlen + crypto_secretbox_MACBYTES - 1; i++) {
+        if (crypto_secretbox_open_easy(m2, c, (unsigned long long) i, nonce,
+                                       k) == 0) {
+            printf("short open() should have failed\n");
+            return 1;
+        }
+    }
+    crypto_secretbox_detached(c, mac, m, (unsigned long long) mlen, nonce, k);
+    if (crypto_secretbox_open_detached(NULL, c, mac, (unsigned long long) mlen,
+                                       nonce, k) != 0) {
+        printf("crypto_secretbox_open_detached() with a NULL message pointer failed\n");
+    }
+    if (crypto_secretbox_open_detached(m2, c, mac, (unsigned long long) mlen,
+                                       nonce, k) != 0) {
+        printf("crypto_secretbox_open_detached() failed\n");
+    }
+    printf("%d\n", memcmp(m, m2, mlen));
+
+    memcpy(c, m, mlen);
+    crypto_secretbox_easy(c, c, (unsigned long long) mlen, nonce, k);
+    printf("%d\n", memcmp(m, c, mlen) == 0);
+    printf("%d\n", memcmp(m, c + crypto_secretbox_MACBYTES, mlen) == 0);
+    if (crypto_secretbox_open_easy(
+            c, c, (unsigned long long) mlen + crypto_secretbox_MACBYTES, nonce,
+            k) != 0) {
+        printf("crypto_secretbox_open_easy() failed\n");
+    }
+    printf("%d\n", memcmp(m, c, mlen));
+
+    sodium_free(m);
+    sodium_free(m2);
+    sodium_free(c);
+    sodium_free(nonce);
+    sodium_free(k);
+    sodium_free(mac);
+
+    return 0;
+}

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

@@ -0,0 +1,5 @@
+0
+0
+0
+0
+0

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

@@ -0,0 +1,329 @@
+
+#define TEST_NAME "secretstream_xchacha20poly1305"
+#include "cmptest.h"
+
+int
+main(void)
+{
+    crypto_secretstream_xchacha20poly1305_state *state, *statesave;
+    crypto_secretstream_xchacha20poly1305_state state_copy;
+    unsigned char      *ad;
+    unsigned char      *header;
+    unsigned char      *k;
+    unsigned char      *c1, *c2, *c3, *csave;
+    unsigned char      *m1, *m2, *m3;
+    unsigned char      *m1_, *m2_, *m3_;
+    unsigned long long  res_len;
+    size_t              ad_len;
+    size_t              m1_len, m2_len, m3_len;
+    int                 ret;
+    unsigned char       tag;
+
+    state = (crypto_secretstream_xchacha20poly1305_state *)
+        sodium_malloc(crypto_secretstream_xchacha20poly1305_statebytes());
+    statesave = (crypto_secretstream_xchacha20poly1305_state *)
+        sodium_malloc(crypto_secretstream_xchacha20poly1305_statebytes());
+    header = (unsigned char *)
+        sodium_malloc(crypto_secretstream_xchacha20poly1305_HEADERBYTES);
+
+    ad_len = randombytes_uniform(100);
+    m1_len = randombytes_uniform(1000);
+    m2_len = randombytes_uniform(1000);
+    m3_len = randombytes_uniform(1000);
+
+    c1 = (unsigned char *)
+        sodium_malloc(m1_len + crypto_secretstream_xchacha20poly1305_ABYTES);
+    c2 = (unsigned char *)
+        sodium_malloc(m2_len + crypto_secretstream_xchacha20poly1305_ABYTES);
+    c3 = (unsigned char *)
+        sodium_malloc(m3_len + crypto_secretstream_xchacha20poly1305_ABYTES);
+    csave = (unsigned char *)
+        sodium_malloc((m1_len | m2_len | m3_len) + crypto_secretstream_xchacha20poly1305_ABYTES);
+
+    ad  = (unsigned char *) sodium_malloc(ad_len);
+    m1  = (unsigned char *) sodium_malloc(m1_len);
+    m2  = (unsigned char *) sodium_malloc(m2_len);
+    m3  = (unsigned char *) sodium_malloc(m3_len);
+    m1_ = (unsigned char *) sodium_malloc(m1_len);
+    m2_ = (unsigned char *) sodium_malloc(m2_len);
+    m3_ = (unsigned char *) sodium_malloc(m3_len);
+
+    randombytes_buf(ad, ad_len);
+
+    randombytes_buf(m1, m1_len);
+    memcpy(m1_, m1, m1_len);
+    randombytes_buf(m2, m2_len);
+    memcpy(m2_, m2, m2_len);
+    randombytes_buf(m3, m3_len);
+    memcpy(m3_, m3, m3_len);
+
+    k = (unsigned char *)
+        sodium_malloc(crypto_secretstream_xchacha20poly1305_KEYBYTES);
+    crypto_secretstream_xchacha20poly1305_keygen(k);
+
+    /* push */
+
+    ret = crypto_secretstream_xchacha20poly1305_init_push(state, header, k);
+    assert(ret == 0);
+
+    ret = crypto_secretstream_xchacha20poly1305_push
+        (state, c1, &res_len, m1, m1_len, NULL, 0, 0);
+    assert(ret == 0);
+    assert(res_len == m1_len + crypto_secretstream_xchacha20poly1305_ABYTES);
+
+    ret = crypto_secretstream_xchacha20poly1305_push
+        (state, c2, NULL, m2, m2_len, ad, 0, 0);
+    assert(ret == 0);
+
+    ret = crypto_secretstream_xchacha20poly1305_push
+        (state, c3, NULL, m3, m3_len, ad, ad_len,
+         crypto_secretstream_xchacha20poly1305_TAG_FINAL);
+    assert(ret == 0);
+
+    /* pull */
+
+    ret = crypto_secretstream_xchacha20poly1305_init_pull(state, header, k);
+    assert(ret == 0);
+
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m1, &res_len, &tag,
+         c1, m1_len + crypto_secretstream_xchacha20poly1305_ABYTES, NULL, 0);
+    assert(ret == 0);
+    assert(tag == 0);
+    assert(memcmp(m1, m1_, m1_len) == 0);
+    assert(res_len == m1_len);
+
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m2, NULL, &tag,
+         c2, m2_len + crypto_secretstream_xchacha20poly1305_ABYTES, NULL, 0);
+    assert(ret == 0);
+    assert(tag == 0);
+    assert(memcmp(m2, m2_, m2_len) == 0);
+
+    if (ad_len > 0) {
+        ret = crypto_secretstream_xchacha20poly1305_pull
+            (state, m3, NULL, &tag,
+             c3, m3_len + crypto_secretstream_xchacha20poly1305_ABYTES, NULL, 0);
+        assert(ret == -1);
+    }
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m3, NULL, &tag,
+         c3, m3_len + crypto_secretstream_xchacha20poly1305_ABYTES, ad, ad_len);
+    assert(ret == 0);
+    assert(tag == crypto_secretstream_xchacha20poly1305_TAG_FINAL);
+    assert(memcmp(m3, m3_, m3_len) == 0);
+
+    /* previous with FINAL tag */
+
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m3, NULL, &tag,
+         c3, m3_len + crypto_secretstream_xchacha20poly1305_ABYTES, ad, ad_len);
+    assert(ret == -1);
+
+    /* previous without a tag */
+
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m2, NULL, &tag,
+         c2, m2_len + crypto_secretstream_xchacha20poly1305_ABYTES, NULL, 0);
+    assert(ret == -1);
+
+    /* short ciphertext */
+
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m2, NULL, &tag, c2,
+         randombytes_uniform(crypto_secretstream_xchacha20poly1305_ABYTES),
+         NULL, 0);
+    assert(ret == -1);
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m2, NULL, &tag, c2, 0, NULL, 0);
+    assert(ret == -1);
+
+    /* empty ciphertext */
+
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m2, NULL, &tag, c2,
+         crypto_secretstream_xchacha20poly1305_ABYTES, NULL, 0);
+    assert(ret == -1);
+
+    /* without explicit rekeying */
+
+    ret = crypto_secretstream_xchacha20poly1305_init_push(state, header, k);
+    assert(ret == 0);
+    ret = crypto_secretstream_xchacha20poly1305_push
+        (state, c1, NULL, m1, m1_len, NULL, 0, 0);
+    assert(ret == 0);
+    ret = crypto_secretstream_xchacha20poly1305_push
+        (state, c2, NULL, m2, m2_len, NULL, 0, 0);
+    assert(ret == 0);
+
+    ret = crypto_secretstream_xchacha20poly1305_init_pull(state, header, k);
+    assert(ret == 0);
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m1, NULL, &tag,
+         c1, m1_len + crypto_secretstream_xchacha20poly1305_ABYTES, NULL, 0);
+    assert(ret == 0);
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m2, NULL, &tag,
+         c2, m2_len + crypto_secretstream_xchacha20poly1305_ABYTES, NULL, 0);
+    assert(ret == 0);
+
+    /* with explicit rekeying */
+
+    ret = crypto_secretstream_xchacha20poly1305_init_push(state, header, k);
+    assert(ret == 0);
+    ret = crypto_secretstream_xchacha20poly1305_push
+        (state, c1, NULL, m1, m1_len, NULL, 0, 0);
+    assert(ret == 0);
+
+    crypto_secretstream_xchacha20poly1305_rekey(state);
+
+    ret = crypto_secretstream_xchacha20poly1305_push
+        (state, c2, NULL, m2, m2_len, NULL, 0, 0);
+    assert(ret == 0);
+
+    ret = crypto_secretstream_xchacha20poly1305_init_pull(state, header, k);
+    assert(ret == 0);
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m1, NULL, &tag,
+         c1, m1_len + crypto_secretstream_xchacha20poly1305_ABYTES, NULL, 0);
+    assert(ret == 0);
+
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m2, NULL, &tag,
+         c2, m2_len + crypto_secretstream_xchacha20poly1305_ABYTES, NULL, 0);
+    assert(ret == -1);
+
+    crypto_secretstream_xchacha20poly1305_rekey(state);
+
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m2, NULL, &tag,
+         c2, m2_len + crypto_secretstream_xchacha20poly1305_ABYTES, NULL, 0);
+    assert(ret == 0);
+
+    /* with explicit rekeying using TAG_REKEY */
+
+    ret = crypto_secretstream_xchacha20poly1305_init_push(state, header, k);
+    assert(ret == 0);
+
+    memcpy(statesave, state, sizeof *state);
+
+    ret = crypto_secretstream_xchacha20poly1305_push
+        (state, c1, NULL, m1, m1_len, NULL, 0, crypto_secretstream_xchacha20poly1305_TAG_REKEY);
+    assert(ret == 0);
+
+    ret = crypto_secretstream_xchacha20poly1305_push
+        (state, c2, NULL, m2, m2_len, NULL, 0, 0);
+    assert(ret == 0);
+
+    memcpy(csave, c2, m2_len + crypto_secretstream_xchacha20poly1305_ABYTES);
+
+    ret = crypto_secretstream_xchacha20poly1305_init_pull(state, header, k);
+    assert(ret == 0);
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m1, NULL, &tag,
+         c1, m1_len + crypto_secretstream_xchacha20poly1305_ABYTES, &tag, 0);
+    assert(ret == 0);
+    assert(tag == crypto_secretstream_xchacha20poly1305_TAG_REKEY);
+
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m2, NULL, &tag,
+         c2, m2_len + crypto_secretstream_xchacha20poly1305_ABYTES, &tag, 0);
+    assert(ret == 0);
+    assert(tag == 0);
+
+    memcpy(state, statesave, sizeof *state);
+
+    ret = crypto_secretstream_xchacha20poly1305_push
+        (state, c1, NULL, m1, m1_len, NULL, 0, 0);
+    assert(ret == 0);
+
+    ret = crypto_secretstream_xchacha20poly1305_push
+        (state, c2, NULL, m2, m2_len, NULL, 0, 0);
+    assert(ret == 0);
+
+    assert(memcmp(csave, c2, m2_len + crypto_secretstream_xchacha20poly1305_ABYTES) != 0);
+
+    /* New stream */
+
+    ret = crypto_secretstream_xchacha20poly1305_init_push(state, header, k);
+    assert(ret == 0);
+
+    ret = crypto_secretstream_xchacha20poly1305_push
+        (state, c1, &res_len, m1, m1_len, NULL, 0,
+         crypto_secretstream_xchacha20poly1305_TAG_PUSH);
+    assert(ret == 0);
+    assert(res_len == m1_len + crypto_secretstream_xchacha20poly1305_ABYTES);
+
+    /* Force a counter overflow, check that the key has been updated
+     * even though the tag was not changed to REKEY */
+
+    memset(state->nonce, 0xff, 4U);
+    state_copy = *state;
+
+    ret = crypto_secretstream_xchacha20poly1305_push
+        (state, c2, NULL, m2, m2_len, ad, 0, 0);
+    assert(ret == 0);
+
+    assert(memcmp(state_copy.k, state->k, sizeof state->k) != 0);
+    assert(memcmp(state_copy.nonce, state->nonce, sizeof state->nonce) != 0);
+    assert(state->nonce[0] == 1U);
+    assert(sodium_is_zero(state->nonce + 1, 3U));
+
+    ret = crypto_secretstream_xchacha20poly1305_init_pull(state, header, k);
+    assert(ret == 0);
+
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m1, &res_len, &tag,
+         c1, m1_len + crypto_secretstream_xchacha20poly1305_ABYTES, NULL, 0);
+    assert(ret == 0);
+    assert(tag == crypto_secretstream_xchacha20poly1305_TAG_PUSH);
+    assert(memcmp(m1, m1_, m1_len) == 0);
+    assert(res_len == m1_len);
+
+    memset(state->nonce, 0xff, 4U);
+
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m2, NULL, &tag,
+         c2, m2_len + crypto_secretstream_xchacha20poly1305_ABYTES, NULL, 0);
+    assert(ret == 0);
+    assert(tag == 0);
+    assert(memcmp(m2, m2_, m2_len) == 0);
+
+    sodium_free(m3_);
+    sodium_free(m2_);
+    sodium_free(m1_);
+    sodium_free(m3);
+    sodium_free(m2);
+    sodium_free(m1);
+    sodium_free(ad);
+    sodium_free(csave);
+    sodium_free(c3);
+    sodium_free(c2);
+    sodium_free(c1);
+    sodium_free(k);
+    sodium_free(header);
+    sodium_free(statesave);
+    sodium_free(state);
+
+    assert(crypto_secretstream_xchacha20poly1305_abytes() ==
+           crypto_secretstream_xchacha20poly1305_ABYTES);
+    assert(crypto_secretstream_xchacha20poly1305_headerbytes() ==
+           crypto_secretstream_xchacha20poly1305_HEADERBYTES);
+    assert(crypto_secretstream_xchacha20poly1305_keybytes() ==
+           crypto_secretstream_xchacha20poly1305_KEYBYTES);
+    assert(crypto_secretstream_xchacha20poly1305_messagebytes_max() ==
+           crypto_secretstream_xchacha20poly1305_MESSAGEBYTES_MAX);
+
+    assert(crypto_secretstream_xchacha20poly1305_tag_message() ==
+           crypto_secretstream_xchacha20poly1305_TAG_MESSAGE);
+    assert(crypto_secretstream_xchacha20poly1305_tag_push() ==
+           crypto_secretstream_xchacha20poly1305_TAG_PUSH);
+    assert(crypto_secretstream_xchacha20poly1305_tag_rekey() ==
+           crypto_secretstream_xchacha20poly1305_TAG_REKEY);
+    assert(crypto_secretstream_xchacha20poly1305_tag_final() ==
+           crypto_secretstream_xchacha20poly1305_TAG_FINAL);
+
+    printf("OK\n");
+
+    return 0;
+}

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

@@ -0,0 +1 @@
+OK

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

@@ -0,0 +1,35 @@
+
+#define TEST_NAME "shorthash"
+#include "cmptest.h"
+
+#define MAXLEN 64
+
+int
+main(void)
+{
+    unsigned char in[MAXLEN];
+    unsigned char out[crypto_shorthash_BYTES];
+    unsigned char k[crypto_shorthash_KEYBYTES];
+    size_t        i;
+    size_t        j;
+
+    for (i = 0; i < crypto_shorthash_KEYBYTES; ++i) {
+        k[i] = (unsigned char) i;
+    }
+    for (i = 0; i < MAXLEN; ++i) {
+        in[i] = (unsigned char) i;
+        crypto_shorthash(out, in, (unsigned long long) i, k);
+        for (j = 0; j < crypto_shorthash_BYTES; ++j) {
+            printf("%02x", (unsigned int) out[j]);
+        }
+        printf("\n");
+    }
+    assert(crypto_shorthash_bytes() > 0);
+    assert(crypto_shorthash_keybytes() > 0);
+    assert(strcmp(crypto_shorthash_primitive(), "siphash24") == 0);
+    assert(crypto_shorthash_bytes() == crypto_shorthash_siphash24_bytes());
+    assert(crypto_shorthash_keybytes() ==
+           crypto_shorthash_siphash24_keybytes());
+
+    return 0;
+}

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

@@ -0,0 +1,64 @@
+310e0edd47db6f72
+fd67dc93c539f874
+5a4fa9d909806c0d
+2d7efbd796666785
+b7877127e09427cf
+8da699cd64557618
+cee3fe586e46c9cb
+37d1018bf50002ab
+6224939a79f5f593
+b0e4a90bdf82009e
+f3b9dd94c5bb5d7a
+a7ad6b22462fb3f4
+fbe50e86bc8f1e75
+903d84c02756ea14
+eef27a8e90ca23f7
+e545be4961ca29a1
+db9bc2577fcc2a3f
+9447be2cf5e99a69
+9cd38d96f0b3c14b
+bd6179a71dc96dbb
+98eea21af25cd6be
+c7673b2eb0cbf2d0
+883ea3e395675393
+c8ce5ccd8c030ca8
+94af49f6c650adb8
+eab8858ade92e1bc
+f315bb5bb835d817
+adcf6b0763612e2f
+a5c91da7acaa4dde
+716595876650a2a6
+28ef495c53a387ad
+42c341d8fa92d832
+ce7cf2722f512771
+e37859f94623f3a7
+381205bb1ab0e012
+ae97a10fd434e015
+b4a31508beff4d31
+81396229f0907902
+4d0cf49ee5d4dcca
+5c73336a76d8bf9a
+d0a704536ba93e0e
+925958fcd6420cad
+a915c29bc8067318
+952b79f3bc0aa6d4
+f21df2e41d4535f9
+87577519048f53a9
+10a56cf5dfcd9adb
+eb75095ccd986cd0
+51a9cb9ecba312e6
+96afadfc2ce666c7
+72fe52975a4364ee
+5a1645b276d592a1
+b274cb8ebf87870a
+6f9bb4203de7b381
+eaecb2a30b22a87f
+9924a43cc1315724
+bd838d3aafbf8db7
+0b1a2a3265d51aea
+135079a3231ce660
+932b2846e4d70666
+e1915f5cb1eca46c
+f325965ca16d629f
+575ff28e60381be5
+724506eb4c328a95