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

package/ios/libsodium-stable/src/libsodium/crypto_kdf/hkdf/kdf_hkdf_sha256.c

@@ -1,123 +0,0 @@
-#include <errno.h>
-#include <string.h>
-
-#include "crypto_auth_hmacsha256.h"
-#include "crypto_kdf.h"
-#include "crypto_kdf_hkdf_sha256.h"
-#include "randombytes.h"
-#include "utils.h"
-
-int
-crypto_kdf_hkdf_sha256_extract_init(crypto_kdf_hkdf_sha256_state *state,
-                                    const unsigned char *salt, size_t salt_len)
-{
-    return crypto_auth_hmacsha256_init(&state->st, salt, salt_len);
-}
-
-int
-crypto_kdf_hkdf_sha256_extract_update(crypto_kdf_hkdf_sha256_state *state,
-                                      const unsigned char *ikm, size_t ikm_len)
-{
-    return crypto_auth_hmacsha256_update(&state->st, ikm, ikm_len);
-}
-
-int
-crypto_kdf_hkdf_sha256_extract_final(crypto_kdf_hkdf_sha256_state *state,
-                                     unsigned char prk[crypto_kdf_hkdf_sha256_KEYBYTES])
-{
-    crypto_auth_hmacsha256_final(&state->st, prk);
-    sodium_memzero(state, sizeof state);
-
-    return 0;
-}
-
-int
-crypto_kdf_hkdf_sha256_extract(
-    unsigned char prk[crypto_kdf_hkdf_sha256_KEYBYTES],
-    const unsigned char *salt, size_t salt_len, const unsigned char *ikm,
-    size_t ikm_len)
-{
-    crypto_kdf_hkdf_sha256_state state;
-
-    crypto_kdf_hkdf_sha256_extract_init(&state, salt, salt_len);
-    crypto_kdf_hkdf_sha256_extract_update(&state, ikm, ikm_len);
-
-    return crypto_kdf_hkdf_sha256_extract_final(&state, prk);
-}
-
-void
-crypto_kdf_hkdf_sha256_keygen(unsigned char prk[crypto_kdf_hkdf_sha256_KEYBYTES])
-{
-    randombytes_buf(prk, crypto_kdf_hkdf_sha256_KEYBYTES);
-}
-
-int
-crypto_kdf_hkdf_sha256_expand(unsigned char *out, size_t out_len,
-                              const char *ctx, size_t ctx_len,
-                              const unsigned char prk[crypto_kdf_hkdf_sha256_KEYBYTES])
-{
-    crypto_auth_hmacsha256_state st;
-    unsigned char                tmp[crypto_auth_hmacsha256_BYTES];
-    size_t                       i;
-    size_t                       left;
-    unsigned char                counter = 1U;
-
-    if (out_len > crypto_kdf_hkdf_sha256_BYTES_MAX) {
-        errno = EINVAL;
-        return -1;
-    }
-    for (i = (size_t) 0U; i + crypto_auth_hmacsha256_BYTES <= out_len;
-         i += crypto_auth_hmacsha256_BYTES) {
-        crypto_auth_hmacsha256_init(&st, prk, crypto_kdf_hkdf_sha256_KEYBYTES);
-        if (i != (size_t) 0U) {
-            crypto_auth_hmacsha256_update(&st,
-                                          &out[i - crypto_auth_hmacsha256_BYTES],
-                                          crypto_auth_hmacsha256_BYTES);
-        }
-        crypto_auth_hmacsha256_update(&st,
-                                      (const unsigned char *) ctx, ctx_len);
-        crypto_auth_hmacsha256_update(&st, &counter, (size_t) 1U);
-        crypto_auth_hmacsha256_final(&st, &out[i]);
-        counter++;
-    }
-    if ((left = out_len & (crypto_auth_hmacsha256_BYTES - 1U)) != (size_t) 0U) {
-        crypto_auth_hmacsha256_init(&st, prk, crypto_kdf_hkdf_sha256_KEYBYTES);
-        if (i != (size_t) 0U) {
-            crypto_auth_hmacsha256_update(&st,
-                                          &out[i - crypto_auth_hmacsha256_BYTES],
-                                          crypto_auth_hmacsha256_BYTES);
-        }
-        crypto_auth_hmacsha256_update(&st,
-                                      (const unsigned char *) ctx, ctx_len);
-        crypto_auth_hmacsha256_update(&st, &counter, (size_t) 1U);
-        crypto_auth_hmacsha256_final(&st, tmp);
-        memcpy(&out[i], tmp, left);
-        sodium_memzero(tmp, sizeof tmp);
-    }
-    sodium_memzero(&st, sizeof st);
-
-    return 0;
-}
-
-size_t
-crypto_kdf_hkdf_sha256_keybytes(void)
-{
-    return crypto_kdf_hkdf_sha256_KEYBYTES;
-}
-
-size_t
-crypto_kdf_hkdf_sha256_bytes_min(void)
-{
-    return crypto_kdf_hkdf_sha256_BYTES_MIN;
-}
-
-size_t
-crypto_kdf_hkdf_sha256_bytes_max(void)
-{
-    return crypto_kdf_hkdf_sha256_BYTES_MAX;
-}
-
-size_t crypto_kdf_hkdf_sha256_statebytes(void)
-{
-    return sizeof(crypto_kdf_hkdf_sha256_state);
-}

package/ios/libsodium-stable/src/libsodium/crypto_kdf/hkdf/kdf_hkdf_sha512.c

@@ -1,123 +0,0 @@
-#include <errno.h>
-#include <string.h>
-
-#include "crypto_auth_hmacsha512.h"
-#include "crypto_kdf.h"
-#include "crypto_kdf_hkdf_sha512.h"
-#include "randombytes.h"
-#include "utils.h"
-
-int
-crypto_kdf_hkdf_sha512_extract_init(crypto_kdf_hkdf_sha512_state *state,
-                                    const unsigned char *salt, size_t salt_len)
-{
-    return crypto_auth_hmacsha512_init(&state->st, salt, salt_len);
-}
-
-int
-crypto_kdf_hkdf_sha512_extract_update(crypto_kdf_hkdf_sha512_state *state,
-                                      const unsigned char *ikm, size_t ikm_len)
-{
-    return crypto_auth_hmacsha512_update(&state->st, ikm, ikm_len);
-}
-
-int
-crypto_kdf_hkdf_sha512_extract_final(crypto_kdf_hkdf_sha512_state *state,
-                                     unsigned char prk[crypto_kdf_hkdf_sha512_KEYBYTES])
-{
-    crypto_auth_hmacsha512_final(&state->st, prk);
-    sodium_memzero(state, sizeof state);
-
-    return 0;
-}
-
-int
-crypto_kdf_hkdf_sha512_extract(
-    unsigned char prk[crypto_kdf_hkdf_sha512_KEYBYTES],
-    const unsigned char *salt, size_t salt_len, const unsigned char *ikm,
-    size_t ikm_len)
-{
-    crypto_kdf_hkdf_sha512_state state;
-
-    crypto_kdf_hkdf_sha512_extract_init(&state, salt, salt_len);
-    crypto_kdf_hkdf_sha512_extract_update(&state, ikm, ikm_len);
-
-    return crypto_kdf_hkdf_sha512_extract_final(&state, prk);
-}
-
-void
-crypto_kdf_hkdf_sha512_keygen(unsigned char prk[crypto_kdf_hkdf_sha512_KEYBYTES])
-{
-    randombytes_buf(prk, crypto_kdf_hkdf_sha512_KEYBYTES);
-}
-
-int
-crypto_kdf_hkdf_sha512_expand(unsigned char *out, size_t out_len,
-                              const char *ctx, size_t ctx_len,
-                              const unsigned char prk[crypto_kdf_hkdf_sha512_KEYBYTES])
-{
-    crypto_auth_hmacsha512_state st;
-    unsigned char                tmp[crypto_auth_hmacsha512_BYTES];
-    size_t                       i;
-    size_t                       left;
-    unsigned char                counter = 1U;
-
-    if (out_len > crypto_kdf_hkdf_sha512_BYTES_MAX) {
-        errno = EINVAL;
-        return -1;
-    }
-    for (i = (size_t) 0U; i + crypto_auth_hmacsha512_BYTES <= out_len;
-         i += crypto_auth_hmacsha512_BYTES) {
-        crypto_auth_hmacsha512_init(&st, prk, crypto_kdf_hkdf_sha512_KEYBYTES);
-        if (i != (size_t) 0U) {
-            crypto_auth_hmacsha512_update(&st,
-                                          &out[i - crypto_auth_hmacsha512_BYTES],
-                                          crypto_auth_hmacsha512_BYTES);
-        }
-        crypto_auth_hmacsha512_update(&st,
-                                      (const unsigned char *) ctx, ctx_len);
-        crypto_auth_hmacsha512_update(&st, &counter, (size_t) 1U);
-        crypto_auth_hmacsha512_final(&st, &out[i]);
-        counter++;
-    }
-    if ((left = out_len & (crypto_auth_hmacsha512_BYTES - 1U)) != (size_t) 0U) {
-        crypto_auth_hmacsha512_init(&st, prk, crypto_kdf_hkdf_sha512_KEYBYTES);
-        if (i != (size_t) 0U) {
-            crypto_auth_hmacsha512_update(&st,
-                                          &out[i - crypto_auth_hmacsha512_BYTES],
-                                          crypto_auth_hmacsha512_BYTES);
-        }
-        crypto_auth_hmacsha512_update(&st,
-                                      (const unsigned char *) ctx, ctx_len);
-        crypto_auth_hmacsha512_update(&st, &counter, (size_t) 1U);
-        crypto_auth_hmacsha512_final(&st, tmp);
-        memcpy(&out[i], tmp, left);
-        sodium_memzero(tmp, sizeof tmp);
-    }
-    sodium_memzero(&st, sizeof st);
-
-    return 0;
-}
-
-size_t
-crypto_kdf_hkdf_sha512_keybytes(void)
-{
-    return crypto_kdf_hkdf_sha512_KEYBYTES;
-}
-
-size_t
-crypto_kdf_hkdf_sha512_bytes_min(void)
-{
-    return crypto_kdf_hkdf_sha512_BYTES_MIN;
-}
-
-size_t
-crypto_kdf_hkdf_sha512_bytes_max(void)
-{
-    return crypto_kdf_hkdf_sha512_BYTES_MAX;
-}
-
-size_t crypto_kdf_hkdf_sha512_statebytes(void)
-{
-    return sizeof(crypto_kdf_hkdf_sha512_state);
-}

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

@@ -1,143 +0,0 @@
-
-#include <stddef.h>
-
-#include "core.h"
-#include "crypto_generichash.h"
-#include "crypto_kx.h"
-#include "crypto_scalarmult.h"
-#include "private/common.h"
-#include "randombytes.h"
-#include "utils.h"
-
-int
-crypto_kx_seed_keypair(unsigned char pk[crypto_kx_PUBLICKEYBYTES],
-                       unsigned char sk[crypto_kx_SECRETKEYBYTES],
-                       const unsigned char seed[crypto_kx_SEEDBYTES])
-{
-    crypto_generichash(sk, crypto_kx_SECRETKEYBYTES,
-                       seed, crypto_kx_SEEDBYTES, NULL, 0);
-    return crypto_scalarmult_base(pk, sk);
-}
-
-int
-crypto_kx_keypair(unsigned char pk[crypto_kx_PUBLICKEYBYTES],
-                  unsigned char sk[crypto_kx_SECRETKEYBYTES])
-{
-    COMPILER_ASSERT(crypto_kx_SECRETKEYBYTES == crypto_scalarmult_SCALARBYTES);
-    COMPILER_ASSERT(crypto_kx_PUBLICKEYBYTES == crypto_scalarmult_BYTES);
-
-    randombytes_buf(sk, crypto_kx_SECRETKEYBYTES);
-    return crypto_scalarmult_base(pk, sk);
-}
-
-int
-crypto_kx_client_session_keys(unsigned char rx[crypto_kx_SESSIONKEYBYTES],
-                              unsigned char tx[crypto_kx_SESSIONKEYBYTES],
-                              const unsigned char client_pk[crypto_kx_PUBLICKEYBYTES],
-                              const unsigned char client_sk[crypto_kx_SECRETKEYBYTES],
-                              const unsigned char server_pk[crypto_kx_PUBLICKEYBYTES])
-{
-    crypto_generichash_state h;
-    unsigned char            q[crypto_scalarmult_BYTES];
-    unsigned char            keys[2 * crypto_kx_SESSIONKEYBYTES];
-    int                      i;
-
-    if (rx == NULL) {
-        rx = tx;
-    }
-    if (tx == NULL) {
-        tx = rx;
-    }
-    if (rx == NULL) {
-        sodium_misuse(); /* LCOV_EXCL_LINE */
-    }
-    if (crypto_scalarmult(q, client_sk, server_pk) != 0) {
-        return -1;
-    }
-    COMPILER_ASSERT(sizeof keys <= crypto_generichash_BYTES_MAX);
-    crypto_generichash_init(&h, NULL, 0U, sizeof keys);
-    crypto_generichash_update(&h, q, crypto_scalarmult_BYTES);
-    sodium_memzero(q, sizeof q);
-    crypto_generichash_update(&h, client_pk, crypto_kx_PUBLICKEYBYTES);
-    crypto_generichash_update(&h, server_pk, crypto_kx_PUBLICKEYBYTES);
-    crypto_generichash_final(&h, keys, sizeof keys);
-    sodium_memzero(&h, sizeof h);
-    for (i = 0; i < crypto_kx_SESSIONKEYBYTES; i++) {
-        rx[i] = keys[i]; /* rx cannot be NULL */
-        tx[i] = keys[i + crypto_kx_SESSIONKEYBYTES]; /* tx cannot be NULL */
-    }
-    sodium_memzero(keys, sizeof keys);
-
-    return 0;
-}
-
-int
-crypto_kx_server_session_keys(unsigned char rx[crypto_kx_SESSIONKEYBYTES],
-                              unsigned char tx[crypto_kx_SESSIONKEYBYTES],
-                              const unsigned char server_pk[crypto_kx_PUBLICKEYBYTES],
-                              const unsigned char server_sk[crypto_kx_SECRETKEYBYTES],
-                              const unsigned char client_pk[crypto_kx_PUBLICKEYBYTES])
-{
-    crypto_generichash_state h;
-    unsigned char            q[crypto_scalarmult_BYTES];
-    unsigned char            keys[2 * crypto_kx_SESSIONKEYBYTES];
-    int                      i;
-
-    if (rx == NULL) {
-        rx = tx;
-    }
-    if (tx == NULL) {
-        tx = rx;
-    }
-    if (rx == NULL) {
-        sodium_misuse(); /* LCOV_EXCL_LINE */
-    }
-    if (crypto_scalarmult(q, server_sk, client_pk) != 0) {
-        return -1;
-    }
-    COMPILER_ASSERT(sizeof keys <= crypto_generichash_BYTES_MAX);
-    crypto_generichash_init(&h, NULL, 0U, sizeof keys);
-    crypto_generichash_update(&h, q, crypto_scalarmult_BYTES);
-    sodium_memzero(q, sizeof q);
-    crypto_generichash_update(&h, client_pk, crypto_kx_PUBLICKEYBYTES);
-    crypto_generichash_update(&h, server_pk, crypto_kx_PUBLICKEYBYTES);
-    crypto_generichash_final(&h, keys, sizeof keys);
-    sodium_memzero(&h, sizeof h);
-    for (i = 0; i < crypto_kx_SESSIONKEYBYTES; i++) {
-        tx[i] = keys[i];
-        rx[i] = keys[i + crypto_kx_SESSIONKEYBYTES];
-    }
-    sodium_memzero(keys, sizeof keys);
-
-    return 0;
-}
-
-size_t
-crypto_kx_publickeybytes(void)
-{
-    return crypto_kx_PUBLICKEYBYTES;
-}
-
-size_t
-crypto_kx_secretkeybytes(void)
-{
-    return crypto_kx_SECRETKEYBYTES;
-}
-
-size_t
-crypto_kx_seedbytes(void)
-{
-    return crypto_kx_SEEDBYTES;
-}
-
-size_t
-crypto_kx_sessionkeybytes(void)
-{
-    return crypto_kx_SESSIONKEYBYTES;
-}
-
-const char *
-crypto_kx_primitive(void)
-{
-    return crypto_kx_PRIMITIVE;
-}

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

@@ -1,71 +0,0 @@
-
-#include "crypto_onetimeauth.h"
-#include "randombytes.h"
-
-size_t
-crypto_onetimeauth_statebytes(void)
-{
-    return sizeof(crypto_onetimeauth_state);
-}
-
-size_t
-crypto_onetimeauth_bytes(void)
-{
-    return crypto_onetimeauth_BYTES;
-}
-
-size_t
-crypto_onetimeauth_keybytes(void)
-{
-    return crypto_onetimeauth_KEYBYTES;
-}
-
-int
-crypto_onetimeauth(unsigned char *out, const unsigned char *in,
-                   unsigned long long inlen, const unsigned char *k)
-{
-    return crypto_onetimeauth_poly1305(out, in, inlen, k);
-}
-
-int
-crypto_onetimeauth_verify(const unsigned char *h, const unsigned char *in,
-                          unsigned long long inlen, const unsigned char *k)
-{
-    return crypto_onetimeauth_poly1305_verify(h, in, inlen, k);
-}
-
-int
-crypto_onetimeauth_init(crypto_onetimeauth_state *state,
-                        const unsigned char *key)
-{
-    return crypto_onetimeauth_poly1305_init
-        ((crypto_onetimeauth_poly1305_state *) state, key);
-}
-
-int
-crypto_onetimeauth_update(crypto_onetimeauth_state *state,
-                          const unsigned char *in,
-                          unsigned long long inlen)
-{
-    return crypto_onetimeauth_poly1305_update
-        ((crypto_onetimeauth_poly1305_state *) state, in, inlen);
-}
-
-int
-crypto_onetimeauth_final(crypto_onetimeauth_state *state,
-                         unsigned char *out)
-{
-    return crypto_onetimeauth_poly1305_final
-        ((crypto_onetimeauth_poly1305_state *) state, out);
-}
-
-const char *
-crypto_onetimeauth_primitive(void)
-{
-    return crypto_onetimeauth_PRIMITIVE;
-}
-
-void crypto_onetimeauth_keygen(unsigned char k[crypto_onetimeauth_KEYBYTES])
-{
-    randombytes_buf(k, crypto_onetimeauth_KEYBYTES);
-}

package/ios/libsodium-stable/src/libsodium/crypto_onetimeauth/poly1305/donna/poly1305_donna.c

@@ -1,124 +0,0 @@
-
-#include "poly1305_donna.h"
-#include "crypto_verify_16.h"
-#include "private/common.h"
-#include "utils.h"
-
-#ifdef HAVE_TI_MODE
-#include "poly1305_donna64.h"
-#else
-#include "poly1305_donna32.h"
-#endif
-#include "../onetimeauth_poly1305.h"
-
-static void
-poly1305_update(poly1305_state_internal_t *st, const unsigned char *m,
-                unsigned long long bytes)
-{
-    unsigned long long i;
-
-    /* handle leftover */
-    if (st->leftover) {
-        unsigned long long want = (poly1305_block_size - st->leftover);
-
-        if (want > bytes) {
-            want = bytes;
-        }
-        for (i = 0; i < want; i++) {
-            st->buffer[st->leftover + i] = m[i];
-        }
-        bytes -= want;
-        m += want;
-        st->leftover += want;
-        if (st->leftover < poly1305_block_size) {
-            return;
-        }
-        poly1305_blocks(st, st->buffer, poly1305_block_size);
-        st->leftover = 0;
-    }
-
-    /* process full blocks */
-    if (bytes >= poly1305_block_size) {
-        unsigned long long want = (bytes & ~(poly1305_block_size - 1));
-
-        poly1305_blocks(st, m, want);
-        m += want;
-        bytes -= want;
-    }
-
-    /* store leftover */
-    if (bytes) {
-        for (i = 0; i < bytes; i++) {
-            st->buffer[st->leftover + i] = m[i];
-        }
-        st->leftover += bytes;
-    }
-}
-
-static int
-crypto_onetimeauth_poly1305_donna(unsigned char *out, const unsigned char *m,
-                                  unsigned long long   inlen,
-                                  const unsigned char *key)
-{
-    CRYPTO_ALIGN(64) poly1305_state_internal_t state;
-
-    poly1305_init(&state, key);
-    poly1305_update(&state, m, inlen);
-    poly1305_finish(&state, out);
-
-    return 0;
-}
-
-static int
-crypto_onetimeauth_poly1305_donna_init(crypto_onetimeauth_poly1305_state *state,
-                                       const unsigned char *key)
-{
-    COMPILER_ASSERT(sizeof(crypto_onetimeauth_poly1305_state) >=
-        sizeof(poly1305_state_internal_t));
-    poly1305_init((poly1305_state_internal_t *) (void *) state, key);
-
-    return 0;
-}
-
-static int
-crypto_onetimeauth_poly1305_donna_update(
-    crypto_onetimeauth_poly1305_state *state, const unsigned char *in,
-    unsigned long long inlen)
-{
-    poly1305_update((poly1305_state_internal_t *) (void *) state, in, inlen);
-
-    return 0;
-}
-
-static int
-crypto_onetimeauth_poly1305_donna_final(
-    crypto_onetimeauth_poly1305_state *state, unsigned char *out)
-{
-    poly1305_finish((poly1305_state_internal_t *) (void *) state, out);
-
-    return 0;
-}
-
-static int
-crypto_onetimeauth_poly1305_donna_verify(const unsigned char *h,
-                                         const unsigned char *in,
-                                         unsigned long long   inlen,
-                                         const unsigned char *k)
-{
-    unsigned char correct[16];
-
-    crypto_onetimeauth_poly1305_donna(correct, in, inlen, k);
-
-    return crypto_verify_16(h, correct);
-}
-
-struct crypto_onetimeauth_poly1305_implementation
-    crypto_onetimeauth_poly1305_donna_implementation = {
-        SODIUM_C99(.onetimeauth =) crypto_onetimeauth_poly1305_donna,
-        SODIUM_C99(.onetimeauth_verify =)
-            crypto_onetimeauth_poly1305_donna_verify,
-        SODIUM_C99(.onetimeauth_init =) crypto_onetimeauth_poly1305_donna_init,
-        SODIUM_C99(.onetimeauth_update =)
-            crypto_onetimeauth_poly1305_donna_update,
-        SODIUM_C99(.onetimeauth_final =) crypto_onetimeauth_poly1305_donna_final
-    };

package/ios/libsodium-stable/src/libsodium/crypto_onetimeauth/poly1305/donna/poly1305_donna.h

@@ -1,12 +0,0 @@
-#ifndef poly1305_donna_H
-#define poly1305_donna_H
-
-#include <stddef.h>
-
-#include "../onetimeauth_poly1305.h"
-#include "crypto_onetimeauth_poly1305.h"
-
-extern struct crypto_onetimeauth_poly1305_implementation
-    crypto_onetimeauth_poly1305_donna_implementation;
-
-#endif /* poly1305_donna_H */