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

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

@@ -1,212 +0,0 @@
-
-#include <errno.h>
-#include <string.h>
-
-#include "core.h"
-#include "crypto_pwhash.h"
-
-int
-crypto_pwhash_alg_argon2i13(void)
-{
-    return crypto_pwhash_ALG_ARGON2I13;
-}
-
-int
-crypto_pwhash_alg_argon2id13(void)
-{
-    return crypto_pwhash_ALG_ARGON2ID13;
-}
-
-int
-crypto_pwhash_alg_default(void)
-{
-    return crypto_pwhash_ALG_DEFAULT;
-}
-
-size_t
-crypto_pwhash_bytes_min(void)
-{
-    return crypto_pwhash_BYTES_MIN;
-}
-
-size_t
-crypto_pwhash_bytes_max(void)
-{
-    return crypto_pwhash_BYTES_MAX;
-}
-
-size_t
-crypto_pwhash_passwd_min(void)
-{
-    return crypto_pwhash_PASSWD_MIN;
-}
-
-size_t
-crypto_pwhash_passwd_max(void)
-{
-    return crypto_pwhash_PASSWD_MAX;
-}
-
-size_t
-crypto_pwhash_saltbytes(void)
-{
-    return crypto_pwhash_SALTBYTES;
-}
-
-size_t
-crypto_pwhash_strbytes(void)
-{
-    return crypto_pwhash_STRBYTES;
-}
-
-const char *
-crypto_pwhash_strprefix(void)
-{
-    return crypto_pwhash_STRPREFIX;
-}
-
-size_t
-crypto_pwhash_opslimit_min(void)
-{
-    return crypto_pwhash_OPSLIMIT_MIN;
-}
-
-size_t
-crypto_pwhash_opslimit_max(void)
-{
-    return crypto_pwhash_OPSLIMIT_MAX;
-}
-
-size_t
-crypto_pwhash_memlimit_min(void)
-{
-    return crypto_pwhash_MEMLIMIT_MIN;
-}
-
-size_t
-crypto_pwhash_memlimit_max(void)
-{
-    return crypto_pwhash_MEMLIMIT_MAX;
-}
-
-size_t
-crypto_pwhash_opslimit_interactive(void)
-{
-    return crypto_pwhash_OPSLIMIT_INTERACTIVE;
-}
-
-size_t
-crypto_pwhash_memlimit_interactive(void)
-{
-    return crypto_pwhash_MEMLIMIT_INTERACTIVE;
-}
-
-size_t
-crypto_pwhash_opslimit_moderate(void)
-{
-    return crypto_pwhash_OPSLIMIT_MODERATE;
-}
-
-size_t
-crypto_pwhash_memlimit_moderate(void)
-{
-    return crypto_pwhash_MEMLIMIT_MODERATE;
-}
-
-size_t
-crypto_pwhash_opslimit_sensitive(void)
-{
-    return crypto_pwhash_OPSLIMIT_SENSITIVE;
-}
-
-size_t
-crypto_pwhash_memlimit_sensitive(void)
-{
-    return crypto_pwhash_MEMLIMIT_SENSITIVE;
-}
-
-int
-crypto_pwhash(unsigned char * const out, unsigned long long outlen,
-              const char * const passwd, unsigned long long passwdlen,
-              const unsigned char * const salt,
-              unsigned long long opslimit, size_t memlimit, int alg)
-{
-    switch (alg) {
-    case crypto_pwhash_ALG_ARGON2I13:
-        return crypto_pwhash_argon2i(out, outlen, passwd, passwdlen, salt,
-                                     opslimit, memlimit, alg);
-    case crypto_pwhash_ALG_ARGON2ID13:
-        return crypto_pwhash_argon2id(out, outlen, passwd, passwdlen, salt,
-                                      opslimit, memlimit, alg);
-    default:
-        errno = EINVAL;
-        return -1;
-    }
-}
-
-int
-crypto_pwhash_str(char out[crypto_pwhash_STRBYTES],
-                  const char * const passwd, unsigned long long passwdlen,
-                  unsigned long long opslimit, size_t memlimit)
-{
-    return crypto_pwhash_argon2id_str(out, passwd, passwdlen,
-                                      opslimit, memlimit);
-}
-
-int
-crypto_pwhash_str_alg(char out[crypto_pwhash_STRBYTES],
-                      const char * const passwd, unsigned long long passwdlen,
-                      unsigned long long opslimit, size_t memlimit, int alg)
-{
-    switch (alg) {
-    case crypto_pwhash_ALG_ARGON2I13:
-        return crypto_pwhash_argon2i_str(out, passwd, passwdlen,
-                                         opslimit, memlimit);
-    case crypto_pwhash_ALG_ARGON2ID13:
-        return crypto_pwhash_argon2id_str(out, passwd, passwdlen,
-                                          opslimit, memlimit);
-    }
-    sodium_misuse();
-    /* NOTREACHED */
-    return -1;
-}
-
-int
-crypto_pwhash_str_verify(const char * str,
-                         const char * const passwd,
-                         unsigned long long passwdlen)
-{
-    if (strncmp(str, crypto_pwhash_argon2id_STRPREFIX,
-                sizeof crypto_pwhash_argon2id_STRPREFIX - 1) == 0) {
-        return crypto_pwhash_argon2id_str_verify(str, passwd, passwdlen);
-    }
-    if (strncmp(str, crypto_pwhash_argon2i_STRPREFIX,
-                sizeof crypto_pwhash_argon2i_STRPREFIX - 1) == 0) {
-        return crypto_pwhash_argon2i_str_verify(str, passwd, passwdlen);
-    }
-    errno = EINVAL;
-
-    return -1;
-}
-
-int
-crypto_pwhash_str_needs_rehash(const char * str,
-                               unsigned long long opslimit, size_t memlimit)
-{
-    if (strncmp(str, crypto_pwhash_argon2id_STRPREFIX,
-                sizeof crypto_pwhash_argon2id_STRPREFIX - 1) == 0) {
-        return crypto_pwhash_argon2id_str_needs_rehash(str, opslimit, memlimit);
-    }
-    if (strncmp(str, crypto_pwhash_argon2i_STRPREFIX,
-                sizeof crypto_pwhash_argon2i_STRPREFIX - 1) == 0) {
-        return crypto_pwhash_argon2i_str_needs_rehash(str, opslimit, memlimit);
-    }
-    errno = EINVAL;
-
-    return -1;
-}
-
-const char *
-crypto_pwhash_primitive(void) {
-    return crypto_pwhash_PRIMITIVE;
-}

package/ios/libsodium-stable/src/libsodium/crypto_pwhash/scryptsalsa208sha256/crypto_scrypt-common.c

@@ -1,268 +0,0 @@
-/*-
- * Copyright 2013 Alexander Peslyak
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <stdint.h>
-#include <string.h>
-
-#include "crypto_pwhash_scryptsalsa208sha256.h"
-#include "crypto_scrypt.h"
-#include "private/common.h"
-#include "randombytes.h"
-#include "runtime.h"
-#include "utils.h"
-
-static const char *const itoa64 =
-    "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-
-static uint8_t *
-encode64_uint32(uint8_t *dst, size_t dstlen, uint32_t src, uint32_t srcbits)
-{
-    uint32_t bit;
-
-    for (bit = 0; bit < srcbits; bit += 6) {
-        if (dstlen < 1) {
-            return NULL; /* LCOV_EXCL_LINE */
-        }
-        *dst++ = itoa64[src & 0x3f];
-        dstlen--;
-        src >>= 6;
-    }
-    return dst;
-}
-
-static uint8_t *
-encode64(uint8_t *dst, size_t dstlen, const uint8_t *src, size_t srclen)
-{
-    size_t i;
-
-    for (i = 0; i < srclen;) {
-        uint8_t *dnext;
-        uint32_t value = 0, bits = 0;
-
-        do {
-            value |= (uint32_t) src[i++] << bits;
-            bits += 8;
-        } while (bits < 24 && i < srclen);
-
-        dnext = encode64_uint32(dst, dstlen, value, bits);
-        if (!dnext) {
-            return NULL; /* LCOV_EXCL_LINE */
-        }
-        dstlen -= dnext - dst;
-        dst = dnext;
-    }
-    return dst;
-}
-
-static int
-decode64_one(uint32_t *dst, uint8_t src)
-{
-    const char *ptr = strchr(itoa64, src);
-
-    if (ptr) {
-        *dst = (uint32_t)(ptr - itoa64);
-        return 0;
-    }
-    *dst = 0;
-
-    return -1;
-}
-
-static const uint8_t *
-decode64_uint32(uint32_t *dst, uint32_t dstbits, const uint8_t *src)
-{
-    uint32_t bit;
-    uint32_t value;
-
-    value = 0;
-    for (bit = 0; bit < dstbits; bit += 6) {
-        uint32_t one;
-        if (decode64_one(&one, *src)) {
-            *dst = 0;
-            return NULL;
-        }
-        src++;
-        value |= one << bit;
-    }
-    *dst = value;
-
-    return src;
-}
-
-const uint8_t *
-escrypt_parse_setting(const uint8_t *setting,
-                      uint32_t *N_log2_p, uint32_t *r_p, uint32_t *p_p)
-{
-    const uint8_t *src;
-
-    if (setting[0] != '$' || setting[1] != '7' || setting[2] != '$') {
-        return NULL;
-    }
-    src = setting + 3;
-
-    if (decode64_one(N_log2_p, *src)) {
-        return NULL;
-    }
-    src++;
-
-    src = decode64_uint32(r_p, 30, src);
-    if (!src) {
-        return NULL;
-    }
-
-    src = decode64_uint32(p_p, 30, src);
-    if (!src) {
-        return NULL;
-    }
-    return src;
-}
-
-uint8_t *
-escrypt_r(escrypt_local_t *local, const uint8_t *passwd, size_t passwdlen,
-          const uint8_t *setting, uint8_t *buf, size_t buflen)
-{
-    uint8_t        hash[crypto_pwhash_scryptsalsa208sha256_STRHASHBYTES];
-    escrypt_kdf_t  escrypt_kdf;
-    const uint8_t *src;
-    const uint8_t *salt;
-    uint8_t       *dst;
-    size_t         prefixlen;
-    size_t         saltlen;
-    size_t         need;
-    uint64_t       N;
-    uint32_t       N_log2;
-    uint32_t       r;
-    uint32_t       p;
-
-    if (buf != NULL) {
-        randombytes_buf(buf, buflen);
-    }
-
-    src = escrypt_parse_setting(setting, &N_log2, &r, &p);
-    if (!src) {
-        return NULL;
-    }
-    N = (uint64_t) 1 << N_log2;
-    prefixlen = src - setting;
-
-    salt = src;
-    src  = (const uint8_t *) strrchr((const char *) salt, '$');
-    if (src) {
-        saltlen = src - salt;
-    } else {
-        saltlen = strlen((const char *) salt);
-    }
-    need = prefixlen + saltlen + 1 +
-           crypto_pwhash_scryptsalsa208sha256_STRHASHBYTES_ENCODED + 1;
-    if (need > buflen || need < saltlen) {
-        return NULL;
-    }
-#ifdef HAVE_EMMINTRIN_H
-    escrypt_kdf =
-        sodium_runtime_has_sse2() ? escrypt_kdf_sse : escrypt_kdf_nosse;
-#else
-    escrypt_kdf = escrypt_kdf_nosse;
-#endif
-    if (escrypt_kdf(local, passwd, passwdlen, salt, saltlen, N, r, p, hash,
-                    sizeof(hash))) {
-        return NULL;
-    }
-    dst = buf;
-    memcpy(dst, setting, prefixlen + saltlen);
-    dst += prefixlen + saltlen;
-    *dst++ = '$';
-
-    dst = encode64(dst, buflen - (dst - buf), hash, sizeof(hash));
-    sodium_memzero(hash, sizeof hash);
-    if (!dst || dst >= buf + buflen) {
-        return NULL; /* Can't happen LCOV_EXCL_LINE */
-    }
-    *dst = 0; /* NUL termination */
-
-    return buf;
-}
-
-uint8_t *
-escrypt_gensalt_r(uint32_t N_log2, uint32_t r, uint32_t p, const uint8_t *src,
-                  size_t srclen, uint8_t *buf, size_t buflen)
-{
-    uint8_t *dst;
-    size_t   prefixlen =
-        (sizeof "$7$" - 1U) + (1U /* N_log2 */) + (5U /* r */) + (5U /* p */);
-    size_t saltlen = BYTES2CHARS(srclen);
-    size_t need;
-
-    need = prefixlen + saltlen + 1;
-    if (need > buflen || need < saltlen || saltlen < srclen) {
-        return NULL; /* LCOV_EXCL_LINE */
-    }
-    if (N_log2 > 63 || ((uint64_t) r * (uint64_t) p >= (1U << 30))) {
-        return NULL; /* LCOV_EXCL_LINE */
-    }
-    dst    = buf;
-    *dst++ = '$';
-    *dst++ = '7';
-    *dst++ = '$';
-
-    *dst++ = itoa64[N_log2];
-
-    dst = encode64_uint32(dst, buflen - (dst - buf), r, 30);
-    if (!dst) {
-        return NULL; /* Can't happen LCOV_EXCL_LINE */
-    }
-    dst = encode64_uint32(dst, buflen - (dst - buf), p, 30);
-    if (!dst) {
-        return NULL; /* Can't happen LCOV_EXCL_LINE */
-    }
-    dst = encode64(dst, buflen - (dst - buf), src, srclen);
-    if (!dst || dst >= buf + buflen) {
-        return NULL; /* Can't happen LCOV_EXCL_LINE */
-    }
-    *dst = 0; /* NUL termination */
-
-    return buf;
-}
-
-int
-crypto_pwhash_scryptsalsa208sha256_ll(const uint8_t *passwd, size_t passwdlen,
-                                      const uint8_t *salt, size_t saltlen,
-                                      uint64_t N, uint32_t r, uint32_t p,
-                                      uint8_t *buf, size_t buflen)
-{
-    escrypt_kdf_t   escrypt_kdf;
-    escrypt_local_t local;
-    int             retval;
-
-    if (escrypt_init_local(&local)) {
-        return -1; /* LCOV_EXCL_LINE */
-    }
-#if defined(HAVE_EMMINTRIN_H)
-    escrypt_kdf =
-        sodium_runtime_has_sse2() ? escrypt_kdf_sse : escrypt_kdf_nosse;
-#else
-    escrypt_kdf = escrypt_kdf_nosse;
-#endif
-    retval = escrypt_kdf(&local, passwd, passwdlen, salt, saltlen, N, r, p, buf,
-                         buflen);
-    if (escrypt_free_local(&local)) {
-        return -1; /* LCOV_EXCL_LINE */
-    }
-    return retval;
-}

package/ios/libsodium-stable/src/libsodium/crypto_pwhash/scryptsalsa208sha256/crypto_scrypt.h

@@ -1,92 +0,0 @@
-/*-
- * Copyright 2009 Colin Percival
- * Copyright 2013 Alexander Peslyak
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * This file was originally written by Colin Percival as part of the Tarsnap
- * online backup system.
- */
-#ifndef crypto_scrypt_H
-#define crypto_scrypt_H
-
-#include <limits.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#define crypto_pwhash_scryptsalsa208sha256_STRPREFIXBYTES 14
-#define crypto_pwhash_scryptsalsa208sha256_STRSETTINGBYTES 57
-#define crypto_pwhash_scryptsalsa208sha256_STRSALTBYTES 32
-#define crypto_pwhash_scryptsalsa208sha256_STRSALTBYTES_ENCODED 43
-#define crypto_pwhash_scryptsalsa208sha256_STRHASHBYTES 32
-#define crypto_pwhash_scryptsalsa208sha256_STRHASHBYTES_ENCODED 43
-
-#define BYTES2CHARS(bytes) ((((bytes) *8) + 5) / 6)
-
-typedef struct {
-    void * base, *aligned;
-    size_t size;
-} escrypt_region_t;
-
-typedef union {
-    uint64_t d[8];
-    uint32_t w[16];
-} escrypt_block_t;
-
-typedef escrypt_region_t escrypt_local_t;
-
-int escrypt_init_local(escrypt_local_t *__local);
-
-int escrypt_free_local(escrypt_local_t *__local);
-
-void *escrypt_alloc_region(escrypt_region_t *region, size_t size);
-int escrypt_free_region(escrypt_region_t *region);
-
-typedef int (*escrypt_kdf_t)(escrypt_local_t *__local, const uint8_t *__passwd,
-                             size_t __passwdlen, const uint8_t *__salt,
-                             size_t __saltlen, uint64_t __N, uint32_t __r,
-                             uint32_t __p, uint8_t *__buf, size_t __buflen);
-
-int escrypt_kdf_nosse(escrypt_local_t *__local, const uint8_t *__passwd,
-                      size_t __passwdlen, const uint8_t *__salt,
-                      size_t __saltlen, uint64_t __N, uint32_t __r,
-                      uint32_t __p, uint8_t *__buf, size_t __buflen);
-
-int escrypt_kdf_sse(escrypt_local_t *__local, const uint8_t *__passwd,
-                    size_t __passwdlen, const uint8_t *__salt,
-                    size_t __saltlen, uint64_t __N, uint32_t __r,
-                    uint32_t __p, uint8_t *__buf, size_t __buflen);
-
-uint8_t *escrypt_r(escrypt_local_t *__local, const uint8_t *__passwd,
-                   size_t __passwdlen, const uint8_t *__setting,
-                   uint8_t *__buf, size_t __buflen);
-
-uint8_t *escrypt_gensalt_r(uint32_t __N_log2, uint32_t __r, uint32_t __p,
-                           const uint8_t *__src, size_t __srclen,
-                           uint8_t *__buf, size_t __buflen);
-
-const uint8_t *escrypt_parse_setting(const uint8_t *setting,
-                                     uint32_t *N_log2_p, uint32_t *r_p,
-                                     uint32_t *p_p);
-
-#endif /* !_CRYPTO_SCRYPT_H_ */