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

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

@@ -0,0 +1,123 @@
+#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

@@ -0,0 +1,123 @@
+#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

@@ -0,0 +1,143 @@
+
+#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

@@ -0,0 +1,71 @@
+
+#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

@@ -0,0 +1,124 @@
+
+#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

@@ -0,0 +1,12 @@
+#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 */