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

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

@@ -1,149 +0,0 @@
-
-#define TEST_NAME "kx"
-#include "cmptest.h"
-
-static const unsigned char small_order_p[crypto_scalarmult_BYTES] = {
-    0xe0, 0xeb, 0x7a, 0x7c, 0x3b, 0x41, 0xb8, 0xae, 0x16, 0x56, 0xe3,
-    0xfa, 0xf1, 0x9f, 0xc4, 0x6a, 0xda, 0x09, 0x8d, 0xeb, 0x9c, 0x32,
-    0xb1, 0xfd, 0x86, 0x62, 0x05, 0x16, 0x5f, 0x49, 0xb8, 0x00
-};
-
-static void
-tv_kx(void)
-{
-    unsigned char *seed;
-    unsigned char *client_pk, *client_sk;
-    unsigned char *client_rx, *client_tx;
-    unsigned char *server_pk, *server_sk;
-    unsigned char *server_rx, *server_tx;
-    char           hex[65];
-    int            i;
-
-    seed = (unsigned char *) sodium_malloc(crypto_kx_SEEDBYTES);
-    for (i = 0; i < crypto_kx_SEEDBYTES; i++) {
-        seed[i] = (unsigned char) i;
-    }
-    client_pk = (unsigned char *) sodium_malloc(crypto_kx_PUBLICKEYBYTES);
-    client_sk = (unsigned char *) sodium_malloc(crypto_kx_SECRETKEYBYTES);
-    crypto_kx_seed_keypair(client_pk, client_sk, seed);
-
-    sodium_bin2hex(hex, sizeof hex, client_pk, crypto_kx_PUBLICKEYBYTES);
-    printf("client_pk: [%s]\n", hex);
-    sodium_bin2hex(hex, sizeof hex, client_sk, crypto_kx_SECRETKEYBYTES);
-    printf("client_sk: [%s]\n", hex);
-
-    server_pk = (unsigned char *) sodium_malloc(crypto_kx_PUBLICKEYBYTES);
-    server_sk = (unsigned char *) sodium_malloc(crypto_kx_SECRETKEYBYTES);
-    crypto_kx_keypair(server_pk, server_sk);
-
-    client_rx = (unsigned char *) sodium_malloc(crypto_kx_SESSIONKEYBYTES);
-    client_tx = (unsigned char *) sodium_malloc(crypto_kx_SESSIONKEYBYTES);
-
-    assert(crypto_kx_client_session_keys(client_rx, client_tx,
-                                         client_pk, client_sk,
-                                         small_order_p) == -1);
-    if (crypto_kx_client_session_keys(client_rx, client_tx,
-                                      client_pk, client_sk, server_pk) != 0) {
-        printf("crypto_kx_client_session_keys() failed\n");
-    }
-
-    server_rx = (unsigned char *) sodium_malloc(crypto_kx_SESSIONKEYBYTES);
-    server_tx = (unsigned char *) sodium_malloc(crypto_kx_SESSIONKEYBYTES);
-
-    assert(crypto_kx_server_session_keys(server_rx, server_tx,
-                                         server_pk, server_sk,
-                                         small_order_p) == -1);
-    if (crypto_kx_server_session_keys(server_rx, server_tx,
-                                      server_pk, server_sk, client_pk) != 0) {
-        printf("crypto_kx_server_session_keys() failed\n");
-    }
-    if (memcmp(server_rx, client_tx, crypto_kx_SESSIONKEYBYTES) != 0 ||
-        memcmp(server_tx, client_rx, crypto_kx_SESSIONKEYBYTES) != 0) {
-        printf("client session keys != server session keys\n");
-    }
-
-    sodium_increment(client_pk, crypto_kx_PUBLICKEYBYTES);
-    if (crypto_kx_server_session_keys(server_rx, server_tx,
-                                      server_pk, server_sk, client_pk) != 0) {
-        printf("crypto_kx_server_session_keys() failed\n");
-    }
-    if (memcmp(server_rx, client_tx, crypto_kx_SESSIONKEYBYTES) == 0 &&
-        memcmp(server_tx, client_rx, crypto_kx_SESSIONKEYBYTES) == 0) {
-        printf("peer's public key is ignored\n");
-    }
-
-    crypto_kx_keypair(client_pk, client_sk);
-    if (crypto_kx_server_session_keys(server_rx, server_tx,
-                                      server_pk, server_sk, client_pk) != 0) {
-        printf("crypto_kx_server_session_keys() failed\n");
-    }
-    if (memcmp(server_rx, client_tx, crypto_kx_SESSIONKEYBYTES) == 0 ||
-        memcmp(server_tx, client_rx, crypto_kx_SESSIONKEYBYTES) == 0) {
-        printf("session keys are constant\n");
-    }
-
-    crypto_kx_seed_keypair(client_pk, client_sk, seed);
-    sodium_increment(seed, crypto_kx_SEEDBYTES);
-    crypto_kx_seed_keypair(server_pk, server_sk, seed);
-    if (crypto_kx_server_session_keys(server_rx, server_tx,
-                                      server_pk, server_sk, client_pk) != 0) {
-        printf("crypto_kx_server_session_keys() failed\n");
-    }
-    sodium_bin2hex(hex, sizeof hex, server_rx, crypto_kx_SESSIONKEYBYTES);
-    printf("server_rx: [%s]\n", hex);
-    sodium_bin2hex(hex, sizeof hex, server_tx, crypto_kx_SESSIONKEYBYTES);
-    printf("server_tx: [%s]\n", hex);
-
-    if (crypto_kx_client_session_keys(client_rx, client_tx,
-                                      client_pk, client_sk, server_pk) != 0) {
-        printf("crypto_kx_client_session_keys() failed\n");
-    }
-    sodium_bin2hex(hex, sizeof hex, client_rx, crypto_kx_SESSIONKEYBYTES);
-    printf("client_rx: [%s]\n", hex);
-    sodium_bin2hex(hex, sizeof hex, client_tx, crypto_kx_SESSIONKEYBYTES);
-    printf("client_tx: [%s]\n", hex);
-
-    randombytes_buf(client_rx, crypto_kx_SESSIONKEYBYTES);
-    randombytes_buf(client_tx, crypto_kx_SESSIONKEYBYTES);
-    randombytes_buf(server_rx, crypto_kx_SESSIONKEYBYTES);
-    randombytes_buf(server_tx, crypto_kx_SESSIONKEYBYTES);
-    if (crypto_kx_client_session_keys(client_rx, NULL,
-                                      client_pk, client_sk, server_pk) != 0 ||
-        crypto_kx_client_session_keys(NULL, client_tx,
-                                      client_pk, client_sk, server_pk) != 0 ||
-        crypto_kx_server_session_keys(server_rx, NULL,
-                                      server_pk, server_sk, client_pk) != 0 ||
-        crypto_kx_server_session_keys(NULL, server_tx,
-                                      server_pk, server_sk, client_pk) != 0) {
-        printf("failure when one of the pointers happens to be NULL");
-    }
-    assert(memcmp(client_rx, client_tx, crypto_kx_SESSIONKEYBYTES) == 0);
-    assert(memcmp(client_tx, server_rx, crypto_kx_SESSIONKEYBYTES) == 0);
-    assert(memcmp(server_rx, server_tx, crypto_kx_SESSIONKEYBYTES) == 0);
-
-    sodium_free(client_rx);
-    sodium_free(client_tx);
-    sodium_free(server_rx);
-    sodium_free(server_tx);
-    sodium_free(server_sk);
-    sodium_free(server_pk);
-    sodium_free(client_sk);
-    sodium_free(client_pk);
-    sodium_free(seed);
-
-    assert(strcmp(crypto_kx_primitive(), crypto_kx_PRIMITIVE) == 0);
-    assert(crypto_kx_publickeybytes() == crypto_kx_PUBLICKEYBYTES);
-    assert(crypto_kx_secretkeybytes() == crypto_kx_SECRETKEYBYTES);
-    assert(crypto_kx_seedbytes() == crypto_kx_SEEDBYTES);
-    assert(crypto_kx_sessionkeybytes() == crypto_kx_SESSIONKEYBYTES);
-
-    printf("tv_kx: ok\n");
-}
-
-int
-main(void)
-{
-    tv_kx();
-
-    return 0;
-}

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

@@ -1,7 +0,0 @@
-client_pk: [0e0216223f147143d32615a91189c288c1728cba3cc5f9f621b1026e03d83129]
-client_sk: [cb2f5160fc1f7e05a55ef49d340b48da2e5a78099d53393351cd579dd42503d6]
-server_rx: [62c8f4fa81800abd0577d99918d129b65deb789af8c8351f391feb0cbf238604]
-server_tx: [749519c68059bce69f7cfcc7b387a3de1a1e8237d110991323bf62870115731a]
-client_rx: [749519c68059bce69f7cfcc7b387a3de1a1e8237d110991323bf62870115731a]
-client_tx: [62c8f4fa81800abd0577d99918d129b65deb789af8c8351f391feb0cbf238604]
-tv_kx: ok

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

@@ -1,187 +0,0 @@
-
-#define TEST_NAME "metamorphic"
-#include "cmptest.h"
-
-#define MAXLEN 512
-#define MAX_ITER 1000
-
-static void
-mm_generichash(void)
-{
-    crypto_generichash_state st;
-    unsigned char *h, *h2;
-    unsigned char *k;
-    unsigned char *m;
-    size_t         hlen;
-    size_t         klen;
-    size_t         mlen;
-    size_t         l1, l2;
-    int            i;
-
-    for (i = 0; i < MAX_ITER; i++) {
-        mlen = randombytes_uniform(MAXLEN);
-        m = (unsigned char *) sodium_malloc(mlen);
-        klen = randombytes_uniform(crypto_generichash_KEYBYTES_MAX -
-                                   crypto_generichash_KEYBYTES_MIN + 1U)
-            + crypto_generichash_KEYBYTES_MIN;
-        k = (unsigned char *) sodium_malloc(klen);
-        hlen = randombytes_uniform(crypto_generichash_BYTES_MAX -
-                                   crypto_generichash_BYTES_MIN + 1U)
-            + crypto_generichash_BYTES_MIN;
-        h = (unsigned char *) sodium_malloc(hlen);
-        h2 = (unsigned char *) sodium_malloc(hlen);
-
-        randombytes_buf(k, klen);
-        randombytes_buf(m, mlen);
-
-        crypto_generichash_init(&st, k, klen, hlen);
-        l1 = randombytes_uniform((uint32_t) mlen);
-        l2 = randombytes_uniform((uint32_t) (mlen - l1));
-        crypto_generichash_update(&st, m, l1);
-        crypto_generichash_update(&st, m + l1, l2);
-        crypto_generichash_update(&st, m + l1 + l2, mlen - l1 - l2);
-        crypto_generichash_final(&st, h, hlen);
-
-        crypto_generichash(h2, hlen, m, mlen, k, klen);
-
-        assert(memcmp(h, h2, hlen) == 0);
-
-        sodium_free(h2);
-        sodium_free(h);
-        sodium_free(k);
-        sodium_free(m);
-    }
-}
-
-static void
-mm_onetimeauth(void)
-{
-    crypto_onetimeauth_state st;
-    unsigned char *h, *h2;
-    unsigned char *k;
-    unsigned char *m;
-    size_t         mlen;
-    size_t         l1, l2;
-    int            i;
-
-    for (i = 0; i < MAX_ITER; i++) {
-        mlen = randombytes_uniform(MAXLEN);
-        m = (unsigned char *) sodium_malloc(mlen);
-        k = (unsigned char *) sodium_malloc(crypto_onetimeauth_KEYBYTES);
-        h = (unsigned char *) sodium_malloc(crypto_onetimeauth_BYTES);
-        h2 = (unsigned char *) sodium_malloc(crypto_onetimeauth_BYTES);
-
-        crypto_onetimeauth_keygen(k);
-        randombytes_buf(m, mlen);
-
-        crypto_onetimeauth_init(&st, k);
-        l1 = randombytes_uniform((uint32_t) mlen);
-        l2 = randombytes_uniform((uint32_t) (mlen - l1));
-        crypto_onetimeauth_update(&st, m, l1);
-        crypto_onetimeauth_update(&st, m + l1, l2);
-        crypto_onetimeauth_update(&st, m + l1 + l2, mlen - l1 - l2);
-        crypto_onetimeauth_final(&st, h);
-
-        crypto_onetimeauth(h2, m, mlen, k);
-
-        assert(memcmp(h, h2, crypto_onetimeauth_BYTES) == 0);
-
-        sodium_free(h2);
-        sodium_free(h);
-        sodium_free(k);
-        sodium_free(m);
-    }
-}
-
-static void
-mm_hmacsha256(void)
-{
-    crypto_auth_hmacsha256_state st;
-    unsigned char *h, *h2;
-    unsigned char *k;
-    unsigned char *m;
-    size_t         mlen;
-    size_t         l1, l2;
-    int            i;
-
-    for (i = 0; i < MAX_ITER; i++) {
-        mlen = randombytes_uniform(MAXLEN);
-        m = (unsigned char *) sodium_malloc(mlen);
-        k = (unsigned char *) sodium_malloc(crypto_auth_hmacsha256_KEYBYTES);
-        h = (unsigned char *) sodium_malloc(crypto_auth_hmacsha256_BYTES);
-        h2 = (unsigned char *) sodium_malloc(crypto_auth_hmacsha256_BYTES);
-
-        crypto_auth_hmacsha256_keygen(k);
-        randombytes_buf(m, mlen);
-
-        crypto_auth_hmacsha256_init(&st, k, crypto_auth_hmacsha256_KEYBYTES);
-        l1 = randombytes_uniform((uint32_t) mlen);
-        l2 = randombytes_uniform((uint32_t) (mlen - l1));
-        crypto_auth_hmacsha256_update(&st, m, l1);
-        crypto_auth_hmacsha256_update(&st, m + l1, l2);
-        crypto_auth_hmacsha256_update(&st, m + l1 + l2, mlen - l1 - l2);
-        crypto_auth_hmacsha256_final(&st, h);
-
-        crypto_auth_hmacsha256(h2, m, mlen, k);
-
-        assert(memcmp(h, h2, crypto_auth_hmacsha256_BYTES) == 0);
-
-        sodium_free(h2);
-        sodium_free(h);
-        sodium_free(k);
-        sodium_free(m);
-    }
-}
-
-static void
-mm_hmacsha512(void)
-{
-    crypto_auth_hmacsha512_state st;
-    unsigned char *h, *h2;
-    unsigned char *k;
-    unsigned char *m;
-    size_t         mlen;
-    size_t         l1, l2;
-    int            i;
-
-    for (i = 0; i < MAX_ITER; i++) {
-        mlen = randombytes_uniform(MAXLEN);
-        m = (unsigned char *) sodium_malloc(mlen);
-        k = (unsigned char *) sodium_malloc(crypto_auth_hmacsha512_KEYBYTES);
-        h = (unsigned char *) sodium_malloc(crypto_auth_hmacsha512_BYTES);
-        h2 = (unsigned char *) sodium_malloc(crypto_auth_hmacsha512_BYTES);
-
-        crypto_auth_hmacsha512_keygen(k);
-        randombytes_buf(m, mlen);
-
-        crypto_auth_hmacsha512_init(&st, k, crypto_auth_hmacsha512_KEYBYTES);
-        l1 = randombytes_uniform((uint32_t) mlen);
-        l2 = randombytes_uniform((uint32_t) (mlen - l1));
-        crypto_auth_hmacsha512_update(&st, m, l1);
-        crypto_auth_hmacsha512_update(&st, m + l1, l2);
-        crypto_auth_hmacsha512_update(&st, m + l1 + l2, mlen - l1 - l2);
-        crypto_auth_hmacsha512_final(&st, h);
-
-        crypto_auth_hmacsha512(h2, m, mlen, k);
-
-        assert(memcmp(h, h2, crypto_auth_hmacsha512_BYTES) == 0);
-
-        sodium_free(h2);
-        sodium_free(h);
-        sodium_free(k);
-        sodium_free(m);
-    }
-}
-
-int
-main(void)
-{
-    mm_generichash();
-    mm_onetimeauth();
-    mm_hmacsha256();
-    mm_hmacsha512();
-
-    printf("OK\n");
-
-    return 0;
-}

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

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

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

@@ -1,187 +0,0 @@
-
-#define TEST_NAME "misuse"
-#include "cmptest.h"
-
-#ifdef HAVE_CATCHABLE_ABRT
-# include <signal.h>
-#ifndef _WIN32
-# include <unistd.h>
-#endif
-
-static void
-sigabrt_handler_15(int sig)
-{
-    (void) sig;
-    _exit(0);
-}
-
-# ifndef SODIUM_LIBRARY_MINIMAL
-static void
-sigabrt_handler_14(int sig)
-{
-    (void) sig;
-    signal(SIGABRT, sigabrt_handler_15);
-    assert(crypto_box_curve25519xchacha20poly1305_easy
-           (guard_page, guard_page, crypto_stream_xchacha20_MESSAGEBYTES_MAX - 1,
-            guard_page, guard_page, guard_page) == -1);
-    _exit(1);
-}
-
-static void
-sigabrt_handler_13(int sig)
-{
-    (void) sig;
-    signal(SIGABRT, sigabrt_handler_14);
-    assert(crypto_box_curve25519xchacha20poly1305_easy_afternm
-           (guard_page, guard_page, crypto_stream_xchacha20_MESSAGEBYTES_MAX - 1,
-            guard_page, guard_page) == -1);
-    _exit(1);
-}
-# endif
-
-static void
-sigabrt_handler_12(int sig)
-{
-    (void) sig;
-# ifdef SODIUM_LIBRARY_MINIMAL
-    signal(SIGABRT, sigabrt_handler_15);
-# else
-    signal(SIGABRT, sigabrt_handler_13);
-# endif
-    assert(crypto_pwhash_str_alg((char *) guard_page,
-                                 "", 0U, 1U, 1U, -1) == -1);
-    _exit(1);
-}
-
-static void
-sigabrt_handler_11(int sig)
-{
-    (void) sig;
-    signal(SIGABRT, sigabrt_handler_12);
-    assert(crypto_box_easy(guard_page, guard_page,
-                           crypto_stream_xsalsa20_MESSAGEBYTES_MAX,
-                           guard_page, guard_page, guard_page) == -1);
-    _exit(1);
-}
-
-static void
-sigabrt_handler_10(int sig)
-{
-    (void) sig;
-    signal(SIGABRT, sigabrt_handler_11);
-    assert(crypto_box_easy_afternm(guard_page, guard_page,
-                                   crypto_stream_xsalsa20_MESSAGEBYTES_MAX,
-                                   guard_page, guard_page) == -1);
-    _exit(1);
-}
-
-static void
-sigabrt_handler_9(int sig)
-{
-    (void) sig;
-    signal(SIGABRT, sigabrt_handler_10);
-    assert(sodium_base642bin(guard_page, 1, (const char *) guard_page, 1,
-                             NULL, NULL, NULL, -1) == -1);
-    _exit(1);
-}
-
-static void
-sigabrt_handler_8(int sig)
-{
-    (void) sig;
-    signal(SIGABRT, sigabrt_handler_9);
-    assert(sodium_bin2base64((char *) guard_page, 1, guard_page, 1,
-                             sodium_base64_VARIANT_ORIGINAL) == NULL);
-    _exit(1);
-}
-
-static void
-sigabrt_handler_7(int sig)
-{
-    (void) sig;
-    signal(SIGABRT, sigabrt_handler_8);
-    assert(sodium_bin2base64((char *) guard_page, 1,
-                             guard_page, 1, -1) == NULL);
-    _exit(1);
-}
-
-static void
-sigabrt_handler_6(int sig)
-{
-    (void) sig;
-    signal(SIGABRT, sigabrt_handler_7);
-    assert(sodium_pad(NULL, guard_page, SIZE_MAX, 16, 1) == -1);
-    _exit(1);
-}
-
-static void
-sigabrt_handler_5(int sig)
-{
-    (void) sig;
-    signal(SIGABRT, sigabrt_handler_6);
-    assert(crypto_aead_xchacha20poly1305_ietf_encrypt(guard_page, NULL, NULL, UINT64_MAX,
-                                                      NULL, 0, NULL,
-                                                      guard_page, guard_page) == -1);
-    _exit(1);
-}
-
-static void
-sigabrt_handler_4(int sig)
-{
-    (void) sig;
-    signal(SIGABRT, sigabrt_handler_5);
-    assert(crypto_aead_chacha20poly1305_ietf_encrypt(guard_page, NULL, NULL, UINT64_MAX,
-                                                     NULL, 0, NULL,
-                                                     guard_page, guard_page) == -1);
-    _exit(1);
-}
-
-static void
-sigabrt_handler_3(int sig)
-{
-    (void) sig;
-    signal(SIGABRT, sigabrt_handler_4);
-    assert(crypto_aead_chacha20poly1305_encrypt(guard_page, NULL, NULL, UINT64_MAX,
-                                                NULL, 0, NULL,
-                                                guard_page, guard_page) == -1);
-    _exit(1);
-}
-
-static void
-sigabrt_handler_2(int sig)
-{
-    (void) sig;
-    signal(SIGABRT, sigabrt_handler_3);
-#if SIZE_MAX > 0x4000000000ULL
-    randombytes_buf_deterministic(guard_page, 0x4000000001ULL, guard_page);
-#else
-    abort();
-#endif
-    _exit(1);
-}
-
-static void
-sigabrt_handler_1(int sig)
-{
-    (void) sig;
-    signal(SIGABRT, sigabrt_handler_2);
-    assert(crypto_kx_server_session_keys(NULL, NULL, guard_page, guard_page,
-                                         guard_page) == -1);
-    _exit(1);
-}
-
-int
-main(void)
-{
-    signal(SIGABRT, sigabrt_handler_1);
-    assert(crypto_kx_client_session_keys(NULL, NULL, guard_page, guard_page,
-                                         guard_page) == -1);
-    return 1;
-}
-#else
-int
-main(void)
-{
-    return 0;
-}
-#endif

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

@@ -1,63 +0,0 @@
-
-#define TEST_NAME "onetimeauth"
-#include "cmptest.h"
-
-static unsigned char rs[32] = {
-    0xee, 0xa6, 0xa7, 0x25, 0x1c, 0x1e, 0x72, 0x91, 0x6d, 0x11, 0xc2,
-    0xcb, 0x21, 0x4d, 0x3c, 0x25, 0x25, 0x39, 0x12, 0x1d, 0x8e, 0x23,
-    0x4e, 0x65, 0x2d, 0x65, 0x1f, 0xa4, 0xc8, 0xcf, 0xf8, 0x80
-};
-
-static unsigned char c[131] = {
-    0x8e, 0x99, 0x3b, 0x9f, 0x48, 0x68, 0x12, 0x73, 0xc2, 0x96, 0x50, 0xba,
-    0x32, 0xfc, 0x76, 0xce, 0x48, 0x33, 0x2e, 0xa7, 0x16, 0x4d, 0x96, 0xa4,
-    0x47, 0x6f, 0xb8, 0xc5, 0x31, 0xa1, 0x18, 0x6a, 0xc0, 0xdf, 0xc1, 0x7c,
-    0x98, 0xdc, 0xe8, 0x7b, 0x4d, 0xa7, 0xf0, 0x11, 0xec, 0x48, 0xc9, 0x72,
-    0x71, 0xd2, 0xc2, 0x0f, 0x9b, 0x92, 0x8f, 0xe2, 0x27, 0x0d, 0x6f, 0xb8,
-    0x63, 0xd5, 0x17, 0x38, 0xb4, 0x8e, 0xee, 0xe3, 0x14, 0xa7, 0xcc, 0x8a,
-    0xb9, 0x32, 0x16, 0x45, 0x48, 0xe5, 0x26, 0xae, 0x90, 0x22, 0x43, 0x68,
-    0x51, 0x7a, 0xcf, 0xea, 0xbd, 0x6b, 0xb3, 0x73, 0x2b, 0xc0, 0xe9, 0xda,
-    0x99, 0x83, 0x2b, 0x61, 0xca, 0x01, 0xb6, 0xde, 0x56, 0x24, 0x4a, 0x9e,
-    0x88, 0xd5, 0xf9, 0xb3, 0x79, 0x73, 0xf6, 0x22, 0xa4, 0x3d, 0x14, 0xa6,
-    0x59, 0x9b, 0x1f, 0x65, 0x4c, 0xb4, 0x5a, 0x74, 0xe3, 0x55, 0xa5
-};
-
-static unsigned char a[16];
-
-int
-main(void)
-{
-    crypto_onetimeauth_state st;
-    int                      i;
-
-    assert(crypto_onetimeauth_statebytes() == sizeof st);
-    crypto_onetimeauth(a, c, 131, rs);
-    for (i = 0; i < 16; ++i) {
-        printf(",0x%02x", (unsigned int) a[i]);
-        if (i % 8 == 7)
-            printf("\n");
-    }
-
-    memset(a, 0, sizeof a);
-    crypto_onetimeauth_init(&st, rs);
-    crypto_onetimeauth_update(&st, c, 100);
-    crypto_onetimeauth_update(&st, c, 0);
-    crypto_onetimeauth_update(&st, c + 100, 31);
-    crypto_onetimeauth_final(&st, a);
-    for (i = 0; i < 16; ++i) {
-        printf(",0x%02x", (unsigned int) a[i]);
-        if (i % 8 == 7)
-            printf("\n");
-    }
-
-    assert(crypto_onetimeauth_bytes() > 0U);
-    assert(crypto_onetimeauth_keybytes() > 0U);
-    assert(strcmp(crypto_onetimeauth_primitive(), "poly1305") == 0);
-    assert(crypto_onetimeauth_poly1305_bytes() == crypto_onetimeauth_bytes());
-    assert(crypto_onetimeauth_poly1305_keybytes() ==
-           crypto_onetimeauth_keybytes());
-    assert(crypto_onetimeauth_statebytes() > 0);
-    assert(crypto_onetimeauth_statebytes() == crypto_onetimeauth_poly1305_statebytes());
-
-    return 0;
-}

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

@@ -1,4 +0,0 @@
-,0xf3,0xff,0xc7,0x70,0x3f,0x94,0x00,0xe5
-,0x2a,0x7d,0xfb,0x4b,0x3d,0x33,0x05,0xd9
-,0xf3,0xff,0xc7,0x70,0x3f,0x94,0x00,0xe5
-,0x2a,0x7d,0xfb,0x4b,0x3d,0x33,0x05,0xd9

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

@@ -1,33 +0,0 @@
-
-#define TEST_NAME "onetimeauth2"
-#include "cmptest.h"
-
-static unsigned char rs[32] = {
-    0xee, 0xa6, 0xa7, 0x25, 0x1c, 0x1e, 0x72, 0x91, 0x6d, 0x11, 0xc2,
-    0xcb, 0x21, 0x4d, 0x3c, 0x25, 0x25, 0x39, 0x12, 0x1d, 0x8e, 0x23,
-    0x4e, 0x65, 0x2d, 0x65, 0x1f, 0xa4, 0xc8, 0xcf, 0xf8, 0x80
-};
-
-static unsigned char c[131] = {
-    0x8e, 0x99, 0x3b, 0x9f, 0x48, 0x68, 0x12, 0x73, 0xc2, 0x96, 0x50, 0xba,
-    0x32, 0xfc, 0x76, 0xce, 0x48, 0x33, 0x2e, 0xa7, 0x16, 0x4d, 0x96, 0xa4,
-    0x47, 0x6f, 0xb8, 0xc5, 0x31, 0xa1, 0x18, 0x6a, 0xc0, 0xdf, 0xc1, 0x7c,
-    0x98, 0xdc, 0xe8, 0x7b, 0x4d, 0xa7, 0xf0, 0x11, 0xec, 0x48, 0xc9, 0x72,
-    0x71, 0xd2, 0xc2, 0x0f, 0x9b, 0x92, 0x8f, 0xe2, 0x27, 0x0d, 0x6f, 0xb8,
-    0x63, 0xd5, 0x17, 0x38, 0xb4, 0x8e, 0xee, 0xe3, 0x14, 0xa7, 0xcc, 0x8a,
-    0xb9, 0x32, 0x16, 0x45, 0x48, 0xe5, 0x26, 0xae, 0x90, 0x22, 0x43, 0x68,
-    0x51, 0x7a, 0xcf, 0xea, 0xbd, 0x6b, 0xb3, 0x73, 0x2b, 0xc0, 0xe9, 0xda,
-    0x99, 0x83, 0x2b, 0x61, 0xca, 0x01, 0xb6, 0xde, 0x56, 0x24, 0x4a, 0x9e,
-    0x88, 0xd5, 0xf9, 0xb3, 0x79, 0x73, 0xf6, 0x22, 0xa4, 0x3d, 0x14, 0xa6,
-    0x59, 0x9b, 0x1f, 0x65, 0x4c, 0xb4, 0x5a, 0x74, 0xe3, 0x55, 0xa5
-};
-
-static unsigned char a[16] = { 0xf3, 0xff, 0xc7, 0x70, 0x3f, 0x94, 0x00, 0xe5,
-                               0x2a, 0x7d, 0xfb, 0x4b, 0x3d, 0x33, 0x05, 0xd9 };
-
-int
-main(void)
-{
-    printf("%d\n", crypto_onetimeauth_verify(a, c, 131, rs));
-    return 0;
-}

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

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

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

@@ -1,36 +0,0 @@
-
-#define TEST_NAME "onetimeauth7"
-#include "cmptest.h"
-
-static unsigned char key[32];
-static unsigned char c[1000];
-static unsigned char a[16];
-
-int
-main(void)
-{
-    int clen;
-
-    for (clen = 0; clen < 1000; ++clen) {
-        crypto_onetimeauth_keygen(key);
-        randombytes_buf(c, clen);
-        crypto_onetimeauth(a, c, clen, key);
-        if (crypto_onetimeauth_verify(a, c, clen, key) != 0) {
-            printf("fail %d\n", clen);
-            return 100;
-        }
-        if (clen > 0) {
-            c[rand() % clen] += 1 + (rand() % 255);
-            if (crypto_onetimeauth_verify(a, c, clen, key) == 0) {
-                printf("forgery %d\n", clen);
-                return 100;
-            }
-            a[rand() % sizeof a] += 1 + (rand() % 255);
-            if (crypto_onetimeauth_verify(a, c, clen, key) == 0) {
-                printf("forgery %d\n", clen);
-                return 100;
-            }
-        }
-    }
-    return 0;
-}