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

package/ios/libsodium-stable/src/libsodium/crypto_secretbox/xsalsa20poly1305/secretbox_xsalsa20poly1305.c

@@ -1,89 +0,0 @@
-#include "crypto_onetimeauth_poly1305.h"
-#include "crypto_secretbox_xsalsa20poly1305.h"
-#include "crypto_stream_xsalsa20.h"
-#include "randombytes.h"
-
-int
-crypto_secretbox_xsalsa20poly1305(unsigned char *c, const unsigned char *m,
-                                  unsigned long long mlen,
-                                  const unsigned char *n,
-                                  const unsigned char *k)
-{
-    int i;
-
-    if (mlen < 32) {
-        return -1;
-    }
-    crypto_stream_xsalsa20_xor(c, m, mlen, n, k);
-    crypto_onetimeauth_poly1305(c + 16, c + 32, mlen - 32, c);
-    for (i = 0; i < 16; ++i) {
-        c[i] = 0;
-    }
-    return 0;
-}
-
-int
-crypto_secretbox_xsalsa20poly1305_open(unsigned char *m, const unsigned char *c,
-                                       unsigned long long clen,
-                                       const unsigned char *n,
-                                       const unsigned char *k)
-{
-    unsigned char subkey[32];
-    int           i;
-
-    if (clen < 32) {
-        return -1;
-    }
-    crypto_stream_xsalsa20(subkey, 32, n, k);
-    if (crypto_onetimeauth_poly1305_verify(c + 16, c + 32,
-                                           clen - 32, subkey) != 0) {
-        return -1;
-    }
-    crypto_stream_xsalsa20_xor(m, c, clen, n, k);
-    for (i = 0; i < 32; ++i) {
-        m[i] = 0;
-    }
-    return 0;
-}
-
-size_t
-crypto_secretbox_xsalsa20poly1305_keybytes(void)
-{
-    return crypto_secretbox_xsalsa20poly1305_KEYBYTES;
-}
-
-size_t
-crypto_secretbox_xsalsa20poly1305_noncebytes(void)
-{
-    return crypto_secretbox_xsalsa20poly1305_NONCEBYTES;
-}
-
-size_t
-crypto_secretbox_xsalsa20poly1305_zerobytes(void)
-{
-    return crypto_secretbox_xsalsa20poly1305_ZEROBYTES;
-}
-
-size_t
-crypto_secretbox_xsalsa20poly1305_boxzerobytes(void)
-{
-    return crypto_secretbox_xsalsa20poly1305_BOXZEROBYTES;
-}
-
-size_t
-crypto_secretbox_xsalsa20poly1305_macbytes(void)
-{
-    return crypto_secretbox_xsalsa20poly1305_MACBYTES;
-}
-
-size_t
-crypto_secretbox_xsalsa20poly1305_messagebytes_max(void)
-{
-    return crypto_secretbox_xsalsa20poly1305_MESSAGEBYTES_MAX;
-}
-
-void
-crypto_secretbox_xsalsa20poly1305_keygen(unsigned char k[crypto_secretbox_xsalsa20poly1305_KEYBYTES])
-{
-    randombytes_buf(k, crypto_secretbox_xsalsa20poly1305_KEYBYTES);
-}

package/ios/libsodium-stable/src/libsodium/crypto_secretstream/xchacha20poly1305/secretstream_xchacha20poly1305.c

@@ -1,313 +0,0 @@
-#include <stdint.h>
-#include <stdlib.h>
-#include <limits.h>
-#include <string.h>
-
-#include "core.h"
-#include "crypto_aead_chacha20poly1305.h"
-#include "crypto_aead_xchacha20poly1305.h"
-#include "crypto_core_hchacha20.h"
-#include "crypto_onetimeauth_poly1305.h"
-#include "crypto_secretstream_xchacha20poly1305.h"
-#include "randombytes.h"
-#include "utils.h"
-
-#include "private/common.h"
-
-#define crypto_secretstream_xchacha20poly1305_COUNTERBYTES  4U
-#define crypto_secretstream_xchacha20poly1305_INONCEBYTES   8U
-
-#define STATE_COUNTER(STATE) ((STATE)->nonce)
-#define STATE_INONCE(STATE)  ((STATE)->nonce + \
-                              crypto_secretstream_xchacha20poly1305_COUNTERBYTES)
-
-static const unsigned char _pad0[16] = { 0 };
-
-static inline void
-_crypto_secretstream_xchacha20poly1305_counter_reset
-    (crypto_secretstream_xchacha20poly1305_state *state)
-{
-    memset(STATE_COUNTER(state), 0,
-           crypto_secretstream_xchacha20poly1305_COUNTERBYTES);
-    STATE_COUNTER(state)[0] = 1;
-}
-
-void
-crypto_secretstream_xchacha20poly1305_keygen
-   (unsigned char k[crypto_secretstream_xchacha20poly1305_KEYBYTES])
-{
-    randombytes_buf(k, crypto_secretstream_xchacha20poly1305_KEYBYTES);
-}
-
-int
-crypto_secretstream_xchacha20poly1305_init_push
-   (crypto_secretstream_xchacha20poly1305_state *state,
-    unsigned char out[crypto_secretstream_xchacha20poly1305_HEADERBYTES],
-    const unsigned char k[crypto_secretstream_xchacha20poly1305_KEYBYTES])
-{
-    COMPILER_ASSERT(crypto_secretstream_xchacha20poly1305_HEADERBYTES ==
-                    crypto_core_hchacha20_INPUTBYTES +
-                    crypto_secretstream_xchacha20poly1305_INONCEBYTES);
-    COMPILER_ASSERT(crypto_secretstream_xchacha20poly1305_HEADERBYTES ==
-                    crypto_aead_xchacha20poly1305_ietf_NPUBBYTES);
-    COMPILER_ASSERT(sizeof state->nonce ==
-                    crypto_secretstream_xchacha20poly1305_INONCEBYTES +
-                    crypto_secretstream_xchacha20poly1305_COUNTERBYTES);
-
-    randombytes_buf(out, crypto_secretstream_xchacha20poly1305_HEADERBYTES);
-    crypto_core_hchacha20(state->k, out, k, NULL);
-    _crypto_secretstream_xchacha20poly1305_counter_reset(state);
-    memcpy(STATE_INONCE(state), out + crypto_core_hchacha20_INPUTBYTES,
-           crypto_secretstream_xchacha20poly1305_INONCEBYTES);
-    memset(state->_pad, 0, sizeof state->_pad);
-
-    return 0;
-}
-
-int
-crypto_secretstream_xchacha20poly1305_init_pull
-   (crypto_secretstream_xchacha20poly1305_state *state,
-    const unsigned char in[crypto_secretstream_xchacha20poly1305_HEADERBYTES],
-    const unsigned char k[crypto_secretstream_xchacha20poly1305_KEYBYTES])
-{
-    crypto_core_hchacha20(state->k, in, k, NULL);
-    _crypto_secretstream_xchacha20poly1305_counter_reset(state);
-    memcpy(STATE_INONCE(state), in + crypto_core_hchacha20_INPUTBYTES,
-           crypto_secretstream_xchacha20poly1305_INONCEBYTES);
-    memset(state->_pad, 0, sizeof state->_pad);
-
-    return 0;
-}
-
-void
-crypto_secretstream_xchacha20poly1305_rekey
-    (crypto_secretstream_xchacha20poly1305_state *state)
-{
-    unsigned char new_key_and_inonce[crypto_stream_chacha20_ietf_KEYBYTES +
-                                     crypto_secretstream_xchacha20poly1305_INONCEBYTES];
-    size_t        i;
-
-    for (i = 0U; i < crypto_stream_chacha20_ietf_KEYBYTES; i++) {
-        new_key_and_inonce[i] = state->k[i];
-    }
-    for (i = 0U; i < crypto_secretstream_xchacha20poly1305_INONCEBYTES; i++) {
-        new_key_and_inonce[crypto_stream_chacha20_ietf_KEYBYTES + i] =
-            STATE_INONCE(state)[i];
-    }
-    crypto_stream_chacha20_ietf_xor(new_key_and_inonce, new_key_and_inonce,
-                                    sizeof new_key_and_inonce,
-                                    state->nonce, state->k);
-    for (i = 0U; i < crypto_stream_chacha20_ietf_KEYBYTES; i++) {
-        state->k[i] = new_key_and_inonce[i];
-    }
-    for (i = 0U; i < crypto_secretstream_xchacha20poly1305_INONCEBYTES; i++) {
-        STATE_INONCE(state)[i] =
-            new_key_and_inonce[crypto_stream_chacha20_ietf_KEYBYTES + i];
-    }
-    _crypto_secretstream_xchacha20poly1305_counter_reset(state);
-}
-
-int
-crypto_secretstream_xchacha20poly1305_push
-   (crypto_secretstream_xchacha20poly1305_state *state,
-    unsigned char *out, unsigned long long *outlen_p,
-    const unsigned char *m, unsigned long long mlen,
-    const unsigned char *ad, unsigned long long adlen, unsigned char tag)
-{
-    crypto_onetimeauth_poly1305_state poly1305_state;
-    unsigned char                     block[64U];
-    unsigned char                     slen[8U];
-    unsigned char                    *c;
-    unsigned char                    *mac;
-
-    if (outlen_p != NULL) {
-        *outlen_p = 0U;
-    }
-    COMPILER_ASSERT(crypto_secretstream_xchacha20poly1305_MESSAGEBYTES_MAX
-                    <= crypto_aead_chacha20poly1305_ietf_MESSAGEBYTES_MAX);
-    if (mlen > crypto_secretstream_xchacha20poly1305_MESSAGEBYTES_MAX) {
-        sodium_misuse();
-    }
-    crypto_stream_chacha20_ietf(block, sizeof block, state->nonce, state->k);
-    crypto_onetimeauth_poly1305_init(&poly1305_state, block);
-    sodium_memzero(block, sizeof block);
-
-    crypto_onetimeauth_poly1305_update(&poly1305_state, ad, adlen);
-    crypto_onetimeauth_poly1305_update(&poly1305_state, _pad0,
-                                       (0x10 - adlen) & 0xf);
-    memset(block, 0, sizeof block);
-    block[0] = tag;
-
-    crypto_stream_chacha20_ietf_xor_ic(block, block, sizeof block,
-                                       state->nonce, 1U, state->k);
-    crypto_onetimeauth_poly1305_update(&poly1305_state, block, sizeof block);
-    out[0] = block[0];
-
-    c = out + (sizeof tag);
-    crypto_stream_chacha20_ietf_xor_ic(c, m, mlen, state->nonce, 2U, state->k);
-    crypto_onetimeauth_poly1305_update(&poly1305_state, c, mlen);
-    crypto_onetimeauth_poly1305_update
-        (&poly1305_state, _pad0, (0x10 - (sizeof block) + mlen) & 0xf);
-
-    STORE64_LE(slen, (uint64_t) adlen);
-    crypto_onetimeauth_poly1305_update(&poly1305_state, slen, sizeof slen);
-    STORE64_LE(slen, (sizeof block) + mlen);
-    crypto_onetimeauth_poly1305_update(&poly1305_state, slen, sizeof slen);
-
-    mac = c + mlen;
-    crypto_onetimeauth_poly1305_final(&poly1305_state, mac);
-    sodium_memzero(&poly1305_state, sizeof poly1305_state);
-
-    COMPILER_ASSERT(crypto_onetimeauth_poly1305_BYTES >=
-                    crypto_secretstream_xchacha20poly1305_INONCEBYTES);
-    XOR_BUF(STATE_INONCE(state), mac,
-            crypto_secretstream_xchacha20poly1305_INONCEBYTES);
-    sodium_increment(STATE_COUNTER(state),
-                     crypto_secretstream_xchacha20poly1305_COUNTERBYTES);
-    if ((tag & crypto_secretstream_xchacha20poly1305_TAG_REKEY) != 0 ||
-        sodium_is_zero(STATE_COUNTER(state),
-                       crypto_secretstream_xchacha20poly1305_COUNTERBYTES)) {
-        crypto_secretstream_xchacha20poly1305_rekey(state);
-    }
-    if (outlen_p != NULL) {
-        *outlen_p = crypto_secretstream_xchacha20poly1305_ABYTES + mlen;
-    }
-    return 0;
-}
-
-int
-crypto_secretstream_xchacha20poly1305_pull
-   (crypto_secretstream_xchacha20poly1305_state *state,
-    unsigned char *m, unsigned long long *mlen_p, unsigned char *tag_p,
-    const unsigned char *in, unsigned long long inlen,
-    const unsigned char *ad, unsigned long long adlen)
-{
-    crypto_onetimeauth_poly1305_state poly1305_state;
-    unsigned char                     block[64U];
-    unsigned char                     slen[8U];
-    unsigned char                     mac[crypto_onetimeauth_poly1305_BYTES];
-    const unsigned char              *c;
-    const unsigned char              *stored_mac;
-    unsigned long long                mlen;
-    unsigned char                     tag;
-
-    if (mlen_p != NULL) {
-        *mlen_p = 0U;
-    }
-    if (tag_p != NULL) {
-        *tag_p = 0xff;
-    }
-    if (inlen < crypto_secretstream_xchacha20poly1305_ABYTES) {
-        return -1;
-    }
-    mlen = inlen - crypto_secretstream_xchacha20poly1305_ABYTES;
-    if (mlen > crypto_secretstream_xchacha20poly1305_MESSAGEBYTES_MAX) {
-        sodium_misuse();
-    }
-    crypto_stream_chacha20_ietf(block, sizeof block, state->nonce, state->k);
-    crypto_onetimeauth_poly1305_init(&poly1305_state, block);
-    sodium_memzero(block, sizeof block);
-
-    crypto_onetimeauth_poly1305_update(&poly1305_state, ad, adlen);
-    crypto_onetimeauth_poly1305_update(&poly1305_state, _pad0,
-                                       (0x10 - adlen) & 0xf);
-
-    memset(block, 0, sizeof block);
-    block[0] = in[0];
-    crypto_stream_chacha20_ietf_xor_ic(block, block, sizeof block,
-                                       state->nonce, 1U, state->k);
-    tag = block[0];
-    block[0] = in[0];
-    crypto_onetimeauth_poly1305_update(&poly1305_state, block, sizeof block);
-
-    c = in + (sizeof tag);
-    crypto_onetimeauth_poly1305_update(&poly1305_state, c, mlen);
-    crypto_onetimeauth_poly1305_update
-        (&poly1305_state, _pad0, (0x10 - (sizeof block) + mlen) & 0xf);
-
-    STORE64_LE(slen, (uint64_t) adlen);
-    crypto_onetimeauth_poly1305_update(&poly1305_state, slen, sizeof slen);
-    STORE64_LE(slen, (sizeof block) + mlen);
-    crypto_onetimeauth_poly1305_update(&poly1305_state, slen, sizeof slen);
-
-    crypto_onetimeauth_poly1305_final(&poly1305_state, mac);
-    sodium_memzero(&poly1305_state, sizeof poly1305_state);
-
-    stored_mac = c + mlen;
-    if (sodium_memcmp(mac, stored_mac, sizeof mac) != 0) {
-        sodium_memzero(mac, sizeof mac);
-        return -1;
-    }
-
-    crypto_stream_chacha20_ietf_xor_ic(m, c, mlen, state->nonce, 2U, state->k);
-    XOR_BUF(STATE_INONCE(state), mac,
-            crypto_secretstream_xchacha20poly1305_INONCEBYTES);
-    sodium_increment(STATE_COUNTER(state),
-                     crypto_secretstream_xchacha20poly1305_COUNTERBYTES);
-    if ((tag & crypto_secretstream_xchacha20poly1305_TAG_REKEY) != 0 ||
-        sodium_is_zero(STATE_COUNTER(state),
-                       crypto_secretstream_xchacha20poly1305_COUNTERBYTES)) {
-        crypto_secretstream_xchacha20poly1305_rekey(state);
-    }
-    if (mlen_p != NULL) {
-        *mlen_p = mlen;
-    }
-    if (tag_p != NULL) {
-        *tag_p = tag;
-    }
-    return 0;
-}
-
-size_t
-crypto_secretstream_xchacha20poly1305_statebytes(void)
-{
-    return sizeof(crypto_secretstream_xchacha20poly1305_state);
-}
-
-size_t
-crypto_secretstream_xchacha20poly1305_abytes(void)
-{
-    return crypto_secretstream_xchacha20poly1305_ABYTES;
-}
-
-size_t
-crypto_secretstream_xchacha20poly1305_headerbytes(void)
-{
-    return crypto_secretstream_xchacha20poly1305_HEADERBYTES;
-}
-
-size_t
-crypto_secretstream_xchacha20poly1305_keybytes(void)
-{
-    return crypto_secretstream_xchacha20poly1305_KEYBYTES;
-}
-
-size_t
-crypto_secretstream_xchacha20poly1305_messagebytes_max(void)
-{
-    return crypto_secretstream_xchacha20poly1305_MESSAGEBYTES_MAX;
-}
-
-unsigned char
-crypto_secretstream_xchacha20poly1305_tag_message(void)
-{
-    return crypto_secretstream_xchacha20poly1305_TAG_MESSAGE;
-}
-
-unsigned char
-crypto_secretstream_xchacha20poly1305_tag_push(void)
-{
-    return crypto_secretstream_xchacha20poly1305_TAG_PUSH;
-}
-
-unsigned char
-crypto_secretstream_xchacha20poly1305_tag_rekey(void)
-{
-    return crypto_secretstream_xchacha20poly1305_TAG_REKEY;
-}
-
-unsigned char
-crypto_secretstream_xchacha20poly1305_tag_final(void)
-{
-    return crypto_secretstream_xchacha20poly1305_TAG_FINAL;
-}

package/ios/libsodium-stable/src/libsodium/crypto_shorthash/crypto_shorthash.c

@@ -1,34 +0,0 @@
-
-#include "crypto_shorthash.h"
-#include "randombytes.h"
-
-size_t
-crypto_shorthash_bytes(void)
-{
-    return crypto_shorthash_BYTES;
-}
-
-size_t
-crypto_shorthash_keybytes(void)
-{
-    return crypto_shorthash_KEYBYTES;
-}
-
-const char *
-crypto_shorthash_primitive(void)
-{
-    return crypto_shorthash_PRIMITIVE;
-}
-
-int
-crypto_shorthash(unsigned char *out, const unsigned char *in,
-                 unsigned long long inlen, const unsigned char *k)
-{
-    return crypto_shorthash_siphash24(out, in, inlen, k);
-}
-
-void
-crypto_shorthash_keygen(unsigned char k[crypto_shorthash_KEYBYTES])
-{
-    randombytes_buf(k, crypto_shorthash_KEYBYTES);
-}

package/ios/libsodium-stable/src/libsodium/crypto_shorthash/siphash24/ref/shorthash_siphash24_ref.c

@@ -1,71 +0,0 @@
-#include "crypto_shorthash_siphash24.h"
-#include "private/common.h"
-#include "shorthash_siphash_ref.h"
-
-int
-crypto_shorthash_siphash24(unsigned char *out, const unsigned char *in,
-                           unsigned long long inlen, const unsigned char *k)
-{
-    /* "somepseudorandomlygeneratedbytes" */
-    uint64_t       v0 = 0x736f6d6570736575ULL;
-    uint64_t       v1 = 0x646f72616e646f6dULL;
-    uint64_t       v2 = 0x6c7967656e657261ULL;
-    uint64_t       v3 = 0x7465646279746573ULL;
-    uint64_t       b;
-    uint64_t       k0 = LOAD64_LE(k);
-    uint64_t       k1 = LOAD64_LE(k + 8);
-    uint64_t       m;
-    const uint8_t *end  = in + inlen - (inlen % sizeof(uint64_t));
-    const int      left = inlen & 7;
-
-    b = ((uint64_t) inlen) << 56;
-    v3 ^= k1;
-    v2 ^= k0;
-    v1 ^= k1;
-    v0 ^= k0;
-    for (; in != end; in += 8) {
-        m = LOAD64_LE(in);
-        v3 ^= m;
-        SIPROUND;
-        SIPROUND;
-        v0 ^= m;
-    }
-    switch (left) {
-    case 7:
-        b |= ((uint64_t) in[6]) << 48;
-        /* FALLTHRU */
-    case 6:
-        b |= ((uint64_t) in[5]) << 40;
-        /* FALLTHRU */
-    case 5:
-        b |= ((uint64_t) in[4]) << 32;
-        /* FALLTHRU */
-    case 4:
-        b |= ((uint64_t) in[3]) << 24;
-        /* FALLTHRU */
-    case 3:
-        b |= ((uint64_t) in[2]) << 16;
-        /* FALLTHRU */
-    case 2:
-        b |= ((uint64_t) in[1]) << 8;
-        /* FALLTHRU */
-    case 1:
-        b |= ((uint64_t) in[0]);
-        break;
-    case 0:
-        break;
-    }
-    v3 ^= b;
-    SIPROUND;
-    SIPROUND;
-    v0 ^= b;
-    v2 ^= 0xff;
-    SIPROUND;
-    SIPROUND;
-    SIPROUND;
-    SIPROUND;
-    b = v0 ^ v1 ^ v2 ^ v3;
-    STORE64_LE(out, b);
-
-    return 0;
-}

package/ios/libsodium-stable/src/libsodium/crypto_shorthash/siphash24/ref/shorthash_siphash_ref.h

@@ -1,24 +0,0 @@
-#ifndef shorthash_siphash_H
-#define shorthash_siphash_H
-
-#include "private/common.h"
-
-#define SIPROUND             \
-    do {                     \
-        v0 += v1;            \
-        v1 = ROTL64(v1, 13); \
-        v1 ^= v0;            \
-        v0 = ROTL64(v0, 32); \
-        v2 += v3;            \
-        v3 = ROTL64(v3, 16); \
-        v3 ^= v2;            \
-        v0 += v3;            \
-        v3 = ROTL64(v3, 21); \
-        v3 ^= v0;            \
-        v2 += v1;            \
-        v1 = ROTL64(v1, 17); \
-        v1 ^= v2;            \
-        v2 = ROTL64(v2, 32); \
-    } while (0)
-
-#endif

package/ios/libsodium-stable/src/libsodium/crypto_shorthash/siphash24/ref/shorthash_siphashx24_ref.c

@@ -1,77 +0,0 @@
-#include "crypto_shorthash_siphash24.h"
-#include "private/common.h"
-#include "shorthash_siphash_ref.h"
-
-int
-crypto_shorthash_siphashx24(unsigned char *out, const unsigned char *in,
-                            unsigned long long inlen, const unsigned char *k)
-{
-    uint64_t       v0 = 0x736f6d6570736575ULL;
-    uint64_t       v1 = 0x646f72616e646f83ULL;
-    uint64_t       v2 = 0x6c7967656e657261ULL;
-    uint64_t       v3 = 0x7465646279746573ULL;
-    uint64_t       b;
-    uint64_t       k0 = LOAD64_LE(k);
-    uint64_t       k1 = LOAD64_LE(k + 8);
-    uint64_t       m;
-    const uint8_t *end  = in + inlen - (inlen % sizeof(uint64_t));
-    const int      left = inlen & 7;
-
-    b = ((uint64_t) inlen) << 56;
-    v3 ^= k1;
-    v2 ^= k0;
-    v1 ^= k1;
-    v0 ^= k0;
-    for (; in != end; in += 8) {
-        m = LOAD64_LE(in);
-        v3 ^= m;
-        SIPROUND;
-        SIPROUND;
-        v0 ^= m;
-    }
-    switch (left) {
-    case 7:
-        b |= ((uint64_t) in[6]) << 48;
-        /* FALLTHRU */
-    case 6:
-        b |= ((uint64_t) in[5]) << 40;
-        /* FALLTHRU */
-    case 5:
-        b |= ((uint64_t) in[4]) << 32;
-        /* FALLTHRU */
-    case 4:
-        b |= ((uint64_t) in[3]) << 24;
-        /* FALLTHRU */
-    case 3:
-        b |= ((uint64_t) in[2]) << 16;
-        /* FALLTHRU */
-    case 2:
-        b |= ((uint64_t) in[1]) << 8;
-        /* FALLTHRU */
-    case 1:
-        b |= ((uint64_t) in[0]);
-        break;
-    case 0:
-        break;
-    }
-    v3 ^= b;
-    SIPROUND;
-    SIPROUND;
-    v0 ^= b;
-    v2 ^= 0xee;
-    SIPROUND;
-    SIPROUND;
-    SIPROUND;
-    SIPROUND;
-    b = v0 ^ v1 ^ v2 ^ v3;
-    STORE64_LE(out, b);
-    v1 ^= 0xdd;
-    SIPROUND;
-    SIPROUND;
-    SIPROUND;
-    SIPROUND;
-    b = v0 ^ v1 ^ v2 ^ v3;
-    STORE64_LE(out + 8, b);
-
-    return 0;
-}

package/ios/libsodium-stable/src/libsodium/crypto_shorthash/siphash24/shorthash_siphash24.c

@@ -1,11 +0,0 @@
-#include "crypto_shorthash_siphash24.h"
-
-size_t
-crypto_shorthash_siphash24_bytes(void) {
-    return crypto_shorthash_siphash24_BYTES;
-}
-
-size_t
-crypto_shorthash_siphash24_keybytes(void) {
-    return crypto_shorthash_siphash24_KEYBYTES;
-}

package/ios/libsodium-stable/src/libsodium/crypto_shorthash/siphash24/shorthash_siphashx24.c

@@ -1,11 +0,0 @@
-#include "crypto_shorthash_siphash24.h"
-
-size_t
-crypto_shorthash_siphashx24_bytes(void) {
-    return crypto_shorthash_siphashx24_BYTES;
-}
-
-size_t
-crypto_shorthash_siphashx24_keybytes(void) {
-    return crypto_shorthash_siphashx24_KEYBYTES;
-}