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

package/ios/libsodium-stable/src/libsodium/crypto_auth/hmacsha256/auth_hmacsha256.c

@@ -1,118 +0,0 @@
-
-#include <stddef.h>
-#include <stdint.h>
-#include <string.h>
-
-#include "crypto_auth_hmacsha256.h"
-#include "crypto_hash_sha256.h"
-#include "crypto_verify_32.h"
-#include "randombytes.h"
-#include "utils.h"
-
-size_t
-crypto_auth_hmacsha256_bytes(void)
-{
-    return crypto_auth_hmacsha256_BYTES;
-}
-
-size_t
-crypto_auth_hmacsha256_keybytes(void)
-{
-    return crypto_auth_hmacsha256_KEYBYTES;
-}
-
-size_t
-crypto_auth_hmacsha256_statebytes(void)
-{
-    return sizeof(crypto_auth_hmacsha256_state);
-}
-
-void
-crypto_auth_hmacsha256_keygen(unsigned char k[crypto_auth_hmacsha256_KEYBYTES])
-{
-    randombytes_buf(k, crypto_auth_hmacsha256_KEYBYTES);
-}
-
-int
-crypto_auth_hmacsha256_init(crypto_auth_hmacsha256_state *state,
-                            const unsigned char *key, size_t keylen)
-{
-    unsigned char pad[64];
-    unsigned char khash[32];
-    size_t        i;
-
-    if (keylen > 64) {
-        crypto_hash_sha256_init(&state->ictx);
-        crypto_hash_sha256_update(&state->ictx, key, keylen);
-        crypto_hash_sha256_final(&state->ictx, khash);
-        key    = khash;
-        keylen = 32;
-    }
-    crypto_hash_sha256_init(&state->ictx);
-    memset(pad, 0x36, 64);
-    for (i = 0; i < keylen; i++) {
-        pad[i] ^= key[i];
-    }
-    crypto_hash_sha256_update(&state->ictx, pad, 64);
-
-    crypto_hash_sha256_init(&state->octx);
-    memset(pad, 0x5c, 64);
-    for (i = 0; i < keylen; i++) {
-        pad[i] ^= key[i];
-    }
-    crypto_hash_sha256_update(&state->octx, pad, 64);
-
-    sodium_memzero((void *) pad, sizeof pad);
-    sodium_memzero((void *) khash, sizeof khash);
-
-    return 0;
-}
-
-int
-crypto_auth_hmacsha256_update(crypto_auth_hmacsha256_state *state,
-                              const unsigned char *in, unsigned long long inlen)
-{
-    crypto_hash_sha256_update(&state->ictx, in, inlen);
-
-    return 0;
-}
-
-int
-crypto_auth_hmacsha256_final(crypto_auth_hmacsha256_state *state,
-                             unsigned char                *out)
-{
-    unsigned char ihash[32];
-
-    crypto_hash_sha256_final(&state->ictx, ihash);
-    crypto_hash_sha256_update(&state->octx, ihash, 32);
-    crypto_hash_sha256_final(&state->octx, out);
-
-    sodium_memzero((void *) ihash, sizeof ihash);
-
-    return 0;
-}
-
-int
-crypto_auth_hmacsha256(unsigned char *out, const unsigned char *in,
-                       unsigned long long inlen, const unsigned char *k)
-{
-    crypto_auth_hmacsha256_state state;
-
-    crypto_auth_hmacsha256_init(&state, k, crypto_auth_hmacsha256_KEYBYTES);
-    crypto_auth_hmacsha256_update(&state, in, inlen);
-    crypto_auth_hmacsha256_final(&state, out);
-
-    return 0;
-}
-
-int
-crypto_auth_hmacsha256_verify(const unsigned char *h, const unsigned char *in,
-                              unsigned long long inlen, const unsigned char *k)
-{
-    unsigned char correct[32];
-
-    crypto_auth_hmacsha256(correct, in, inlen, k);
-
-    return crypto_verify_32(h, correct) | (-(h == correct)) |
-           sodium_memcmp(correct, h, 32);
-}

package/ios/libsodium-stable/src/libsodium/crypto_auth/hmacsha512/auth_hmacsha512.c

@@ -1,118 +0,0 @@
-
-#include <stddef.h>
-#include <stdint.h>
-#include <string.h>
-
-#include "crypto_auth_hmacsha512.h"
-#include "crypto_hash_sha512.h"
-#include "crypto_verify_64.h"
-#include "randombytes.h"
-#include "utils.h"
-
-size_t
-crypto_auth_hmacsha512_bytes(void)
-{
-    return crypto_auth_hmacsha512_BYTES;
-}
-
-size_t
-crypto_auth_hmacsha512_keybytes(void)
-{
-    return crypto_auth_hmacsha512_KEYBYTES;
-}
-
-size_t
-crypto_auth_hmacsha512_statebytes(void)
-{
-    return sizeof(crypto_auth_hmacsha512_state);
-}
-
-void
-crypto_auth_hmacsha512_keygen(unsigned char k[crypto_auth_hmacsha512_KEYBYTES])
-{
-    randombytes_buf(k, crypto_auth_hmacsha512_KEYBYTES);
-}
-
-int
-crypto_auth_hmacsha512_init(crypto_auth_hmacsha512_state *state,
-                            const unsigned char *key, size_t keylen)
-{
-    unsigned char pad[128];
-    unsigned char khash[64];
-    size_t        i;
-
-    if (keylen > 128) {
-        crypto_hash_sha512_init(&state->ictx);
-        crypto_hash_sha512_update(&state->ictx, key, keylen);
-        crypto_hash_sha512_final(&state->ictx, khash);
-        key    = khash;
-        keylen = 64;
-    }
-    crypto_hash_sha512_init(&state->ictx);
-    memset(pad, 0x36, 128);
-    for (i = 0; i < keylen; i++) {
-        pad[i] ^= key[i];
-    }
-    crypto_hash_sha512_update(&state->ictx, pad, 128);
-
-    crypto_hash_sha512_init(&state->octx);
-    memset(pad, 0x5c, 128);
-    for (i = 0; i < keylen; i++) {
-        pad[i] ^= key[i];
-    }
-    crypto_hash_sha512_update(&state->octx, pad, 128);
-
-    sodium_memzero((void *) pad, sizeof pad);
-    sodium_memzero((void *) khash, sizeof khash);
-
-    return 0;
-}
-
-int
-crypto_auth_hmacsha512_update(crypto_auth_hmacsha512_state *state,
-                              const unsigned char *in, unsigned long long inlen)
-{
-    crypto_hash_sha512_update(&state->ictx, in, inlen);
-
-    return 0;
-}
-
-int
-crypto_auth_hmacsha512_final(crypto_auth_hmacsha512_state *state,
-                             unsigned char                *out)
-{
-    unsigned char ihash[64];
-
-    crypto_hash_sha512_final(&state->ictx, ihash);
-    crypto_hash_sha512_update(&state->octx, ihash, 64);
-    crypto_hash_sha512_final(&state->octx, out);
-
-    sodium_memzero((void *) ihash, sizeof ihash);
-
-    return 0;
-}
-
-int
-crypto_auth_hmacsha512(unsigned char *out, const unsigned char *in,
-                       unsigned long long inlen, const unsigned char *k)
-{
-    crypto_auth_hmacsha512_state state;
-
-    crypto_auth_hmacsha512_init(&state, k, crypto_auth_hmacsha512_KEYBYTES);
-    crypto_auth_hmacsha512_update(&state, in, inlen);
-    crypto_auth_hmacsha512_final(&state, out);
-
-    return 0;
-}
-
-int
-crypto_auth_hmacsha512_verify(const unsigned char *h, const unsigned char *in,
-                              unsigned long long inlen, const unsigned char *k)
-{
-    unsigned char correct[64];
-
-    crypto_auth_hmacsha512(correct, in, inlen, k);
-
-    return crypto_verify_64(h, correct) | (-(h == correct)) |
-           sodium_memcmp(correct, h, 64);
-}

package/ios/libsodium-stable/src/libsodium/crypto_auth/hmacsha512256/auth_hmacsha512256.c

@@ -1,93 +0,0 @@
-
-#include <stddef.h>
-#include <stdint.h>
-#include <string.h>
-
-#include "crypto_auth_hmacsha512.h"
-#include "crypto_auth_hmacsha512256.h"
-#include "crypto_hash_sha512.h"
-#include "crypto_verify_32.h"
-#include "randombytes.h"
-#include "utils.h"
-
-size_t
-crypto_auth_hmacsha512256_bytes(void)
-{
-    return crypto_auth_hmacsha512256_BYTES;
-}
-
-size_t
-crypto_auth_hmacsha512256_keybytes(void)
-{
-    return crypto_auth_hmacsha512256_KEYBYTES;
-}
-
-size_t
-crypto_auth_hmacsha512256_statebytes(void)
-{
-    return sizeof(crypto_auth_hmacsha512256_state);
-}
-
-void
-crypto_auth_hmacsha512256_keygen(
-    unsigned char k[crypto_auth_hmacsha512256_KEYBYTES])
-{
-    randombytes_buf(k, crypto_auth_hmacsha512256_KEYBYTES);
-}
-
-int
-crypto_auth_hmacsha512256_init(crypto_auth_hmacsha512256_state *state,
-                               const unsigned char *key, size_t keylen)
-{
-    return crypto_auth_hmacsha512_init((crypto_auth_hmacsha512_state *) state,
-                                       key, keylen);
-}
-
-int
-crypto_auth_hmacsha512256_update(crypto_auth_hmacsha512256_state *state,
-                                 const unsigned char             *in,
-                                 unsigned long long               inlen)
-{
-    return crypto_auth_hmacsha512_update((crypto_auth_hmacsha512_state *) state,
-                                         in, inlen);
-}
-
-int
-crypto_auth_hmacsha512256_final(crypto_auth_hmacsha512256_state *state,
-                                unsigned char                   *out)
-{
-    unsigned char out0[64];
-
-    crypto_auth_hmacsha512_final((crypto_auth_hmacsha512_state *) state, out0);
-    memcpy(out, out0, 32);
-
-    return 0;
-}
-
-int
-crypto_auth_hmacsha512256(unsigned char *out, const unsigned char *in,
-                          unsigned long long inlen, const unsigned char *k)
-{
-    crypto_auth_hmacsha512256_state state;
-
-    crypto_auth_hmacsha512256_init(&state, k,
-                                   crypto_auth_hmacsha512256_KEYBYTES);
-    crypto_auth_hmacsha512256_update(&state, in, inlen);
-    crypto_auth_hmacsha512256_final(&state, out);
-
-    return 0;
-}
-
-int
-crypto_auth_hmacsha512256_verify(const unsigned char *h,
-                                 const unsigned char *in,
-                                 unsigned long long   inlen,
-                                 const unsigned char *k)
-{
-    unsigned char correct[32];
-
-    crypto_auth_hmacsha512256(correct, in, inlen, k);
-
-    return crypto_verify_32(h, correct) | (-(h == correct)) |
-           sodium_memcmp(correct, h, 32);
-}

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

@@ -1,114 +0,0 @@
-
-#include "crypto_box.h"
-
-size_t
-crypto_box_seedbytes(void)
-{
-    return crypto_box_SEEDBYTES;
-}
-
-size_t
-crypto_box_publickeybytes(void)
-{
-    return crypto_box_PUBLICKEYBYTES;
-}
-
-size_t
-crypto_box_secretkeybytes(void)
-{
-    return crypto_box_SECRETKEYBYTES;
-}
-
-size_t
-crypto_box_beforenmbytes(void)
-{
-    return crypto_box_BEFORENMBYTES;
-}
-
-size_t
-crypto_box_noncebytes(void)
-{
-    return crypto_box_NONCEBYTES;
-}
-
-size_t
-crypto_box_zerobytes(void)
-{
-    return crypto_box_ZEROBYTES;
-}
-
-size_t
-crypto_box_boxzerobytes(void)
-{
-    return crypto_box_BOXZEROBYTES;
-}
-
-size_t
-crypto_box_macbytes(void)
-{
-    return crypto_box_MACBYTES;
-}
-
-size_t
-crypto_box_messagebytes_max(void)
-{
-    return crypto_box_MESSAGEBYTES_MAX;
-}
-
-const char *
-crypto_box_primitive(void)
-{
-    return crypto_box_PRIMITIVE;
-}
-
-int
-crypto_box_seed_keypair(unsigned char *pk, unsigned char *sk,
-                        const unsigned char *seed)
-{
-    return crypto_box_curve25519xsalsa20poly1305_seed_keypair(pk, sk, seed);
-}
-
-int
-crypto_box_keypair(unsigned char *pk, unsigned char *sk)
-{
-    return crypto_box_curve25519xsalsa20poly1305_keypair(pk, sk);
-}
-
-int
-crypto_box_beforenm(unsigned char *k, const unsigned char *pk,
-                    const unsigned char *sk)
-{
-    return crypto_box_curve25519xsalsa20poly1305_beforenm(k, pk, sk);
-}
-
-int
-crypto_box_afternm(unsigned char *c, const unsigned char *m,
-                   unsigned long long mlen, const unsigned char *n,
-                   const unsigned char *k)
-{
-    return crypto_box_curve25519xsalsa20poly1305_afternm(c, m, mlen, n, k);
-}
-
-int
-crypto_box_open_afternm(unsigned char *m, const unsigned char *c,
-                        unsigned long long clen, const unsigned char *n,
-                        const unsigned char *k)
-{
-    return crypto_box_curve25519xsalsa20poly1305_open_afternm(m, c, clen, n, k);
-}
-
-int
-crypto_box(unsigned char *c, const unsigned char *m,
-           unsigned long long mlen, const unsigned char *n,
-           const unsigned char *pk, const unsigned char *sk)
-{
-    return crypto_box_curve25519xsalsa20poly1305(c, m, mlen, n, pk, sk);
-}
-
-int
-crypto_box_open(unsigned char *m, const unsigned char *c,
-                unsigned long long clen, const unsigned char *n,
-                const unsigned char *pk, const unsigned char *sk)
-{
-    return crypto_box_curve25519xsalsa20poly1305_open(m, c, clen, n, pk, sk);
-}

package/ios/libsodium-stable/src/libsodium/crypto_box/crypto_box_easy.c

@@ -1,115 +0,0 @@
-
-#include <limits.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-#include "core.h"
-#include "crypto_box.h"
-#include "crypto_secretbox.h"
-#include "private/common.h"
-#include "utils.h"
-
-int
-crypto_box_detached_afternm(unsigned char *c, unsigned char *mac,
-                            const unsigned char *m, unsigned long long mlen,
-                            const unsigned char *n, const unsigned char *k)
-{
-    return crypto_secretbox_detached(c, mac, m, mlen, n, k);
-}
-
-int
-crypto_box_detached(unsigned char *c, unsigned char *mac,
-                    const unsigned char *m, unsigned long long mlen,
-                    const unsigned char *n, const unsigned char *pk,
-                    const unsigned char *sk)
-{
-    unsigned char k[crypto_box_BEFORENMBYTES];
-    int           ret;
-
-    COMPILER_ASSERT(crypto_box_BEFORENMBYTES >= crypto_secretbox_KEYBYTES);
-    if (crypto_box_beforenm(k, pk, sk) != 0) {
-        return -1;
-    }
-    ret = crypto_box_detached_afternm(c, mac, m, mlen, n, k);
-    sodium_memzero(k, sizeof k);
-
-    return ret;
-}
-
-int
-crypto_box_easy_afternm(unsigned char *c, const unsigned char *m,
-                        unsigned long long mlen, const unsigned char *n,
-                        const unsigned char *k)
-{
-    if (mlen > crypto_box_MESSAGEBYTES_MAX) {
-        sodium_misuse();
-    }
-    return crypto_box_detached_afternm(c + crypto_box_MACBYTES, c, m, mlen, n,
-                                       k);
-}
-
-int
-crypto_box_easy(unsigned char *c, const unsigned char *m,
-                unsigned long long mlen, const unsigned char *n,
-                const unsigned char *pk, const unsigned char *sk)
-{
-    if (mlen > crypto_box_MESSAGEBYTES_MAX) {
-        sodium_misuse();
-    }
-    return crypto_box_detached(c + crypto_box_MACBYTES, c, m, mlen, n,
-                               pk, sk);
-}
-
-int
-crypto_box_open_detached_afternm(unsigned char *m, const unsigned char *c,
-                                 const unsigned char *mac,
-                                 unsigned long long clen,
-                                 const unsigned char *n,
-                                 const unsigned char *k)
-{
-    return crypto_secretbox_open_detached(m, c, mac, clen, n, k);
-}
-
-int
-crypto_box_open_detached(unsigned char *m, const unsigned char *c,
-                         const unsigned char *mac,
-                         unsigned long long clen, const unsigned char *n,
-                         const unsigned char *pk, const unsigned char *sk)
-{
-    unsigned char k[crypto_box_BEFORENMBYTES];
-    int           ret;
-
-    if (crypto_box_beforenm(k, pk, sk) != 0) {
-        return -1;
-    }
-    ret = crypto_box_open_detached_afternm(m, c, mac, clen, n, k);
-    sodium_memzero(k, sizeof k);
-
-    return ret;
-}
-
-int
-crypto_box_open_easy_afternm(unsigned char *m, const unsigned char *c,
-                             unsigned long long clen, const unsigned char *n,
-                             const unsigned char *k)
-{
-    if (clen < crypto_box_MACBYTES) {
-        return -1;
-    }
-    return crypto_box_open_detached_afternm(m, c + crypto_box_MACBYTES, c,
-                                            clen - crypto_box_MACBYTES,
-                                            n, k);
-}
-
-int
-crypto_box_open_easy(unsigned char *m, const unsigned char *c,
-                     unsigned long long clen, const unsigned char *n,
-                     const unsigned char *pk, const unsigned char *sk)
-{
-    if (clen < crypto_box_MACBYTES) {
-        return -1;
-    }
-    return crypto_box_open_detached(m, c + crypto_box_MACBYTES, c,
-                                    clen - crypto_box_MACBYTES,
-                                    n, pk, sk);
-}

package/ios/libsodium-stable/src/libsodium/crypto_box/crypto_box_seal.c

@@ -1,68 +0,0 @@
-
-#include <string.h>
-
-#include "crypto_box.h"
-#include "crypto_generichash.h"
-#include "private/common.h"
-#include "utils.h"
-
-static int
-_crypto_box_seal_nonce(unsigned char *nonce,
-                       const unsigned char *pk1, const unsigned char *pk2)
-{
-    crypto_generichash_state st;
-
-    crypto_generichash_init(&st, NULL, 0U, crypto_box_NONCEBYTES);
-    crypto_generichash_update(&st, pk1, crypto_box_PUBLICKEYBYTES);
-    crypto_generichash_update(&st, pk2, crypto_box_PUBLICKEYBYTES);
-    crypto_generichash_final(&st, nonce, crypto_box_NONCEBYTES);
-
-    return 0;
-}
-
-int
-crypto_box_seal(unsigned char *c, const unsigned char *m,
-                unsigned long long mlen, const unsigned char *pk)
-{
-    unsigned char nonce[crypto_box_NONCEBYTES];
-    unsigned char epk[crypto_box_PUBLICKEYBYTES];
-    unsigned char esk[crypto_box_SECRETKEYBYTES];
-    int           ret;
-
-    if (crypto_box_keypair(epk, esk) != 0) {
-        return -1; /* LCOV_EXCL_LINE */
-    }
-    _crypto_box_seal_nonce(nonce, epk, pk);
-    ret = crypto_box_easy(c + crypto_box_PUBLICKEYBYTES, m, mlen,
-                          nonce, pk, esk);
-    memcpy(c, epk, crypto_box_PUBLICKEYBYTES);
-    sodium_memzero(esk, sizeof esk);
-    sodium_memzero(epk, sizeof epk);
-    sodium_memzero(nonce, sizeof nonce);
-
-    return ret;
-}
-
-int
-crypto_box_seal_open(unsigned char *m, const unsigned char *c,
-                     unsigned long long clen,
-                     const unsigned char *pk, const unsigned char *sk)
-{
-    unsigned char nonce[crypto_box_NONCEBYTES];
-
-    if (clen < crypto_box_SEALBYTES) {
-        return -1;
-    }
-    _crypto_box_seal_nonce(nonce, c, pk);
-
-    COMPILER_ASSERT(crypto_box_PUBLICKEYBYTES < crypto_box_SEALBYTES);
-    return crypto_box_open_easy(m, c + crypto_box_PUBLICKEYBYTES,
-                                clen - crypto_box_PUBLICKEYBYTES,
-                                nonce, c, sk);
-}
-
-size_t
-crypto_box_sealbytes(void)
-{
-    return crypto_box_SEALBYTES;
-}