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

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

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

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

@@ -0,0 +1,92 @@
+/*-
+ * 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_ */