rbnacl-libsodium 1.0.11 → 1.0.13

data/vendor/libsodium/src/libsodium/crypto_pwhash/argon2/pwhash_argon2id.c

@@ -0,0 +1,213 @@
+
+#include <errno.h>
+#include <limits.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "argon2-core.h"
+#include "argon2.h"
+#include "crypto_pwhash_argon2id.h"
+#include "randombytes.h"
+#include "utils.h"
+
+#define STR_HASHBYTES 32U
+
+int
+crypto_pwhash_argon2id_alg_argon2id13(void)
+{
+    return crypto_pwhash_argon2id_ALG_ARGON2ID13;
+}
+
+size_t
+crypto_pwhash_argon2id_bytes_min(void)
+{
+    return crypto_pwhash_argon2id_BYTES_MIN;
+}
+
+size_t
+crypto_pwhash_argon2id_bytes_max(void)
+{
+    return crypto_pwhash_argon2id_BYTES_MAX;
+}
+
+size_t
+crypto_pwhash_argon2id_passwd_min(void)
+{
+    return crypto_pwhash_argon2id_PASSWD_MIN;
+}
+
+size_t
+crypto_pwhash_argon2id_passwd_max(void)
+{
+    return crypto_pwhash_argon2id_PASSWD_MAX;
+}
+
+size_t
+crypto_pwhash_argon2id_saltbytes(void)
+{
+    return crypto_pwhash_argon2id_SALTBYTES;
+}
+
+size_t
+crypto_pwhash_argon2id_strbytes(void)
+{
+    return crypto_pwhash_argon2id_STRBYTES;
+}
+
+const char*
+crypto_pwhash_argon2id_strprefix(void)
+{
+    return crypto_pwhash_argon2id_STRPREFIX;
+}
+
+size_t
+crypto_pwhash_argon2id_opslimit_min(void)
+{
+    return crypto_pwhash_argon2id_OPSLIMIT_MIN;
+}
+
+size_t
+crypto_pwhash_argon2id_opslimit_max(void)
+{
+    return crypto_pwhash_argon2id_OPSLIMIT_MAX;
+}
+
+size_t
+crypto_pwhash_argon2id_memlimit_min(void)
+{
+    return crypto_pwhash_argon2id_MEMLIMIT_MIN;
+}
+
+size_t
+crypto_pwhash_argon2id_memlimit_max(void)
+{
+    return crypto_pwhash_argon2id_MEMLIMIT_MAX;
+}
+
+size_t
+crypto_pwhash_argon2id_opslimit_interactive(void)
+{
+    return crypto_pwhash_argon2id_OPSLIMIT_INTERACTIVE;
+}
+
+size_t
+crypto_pwhash_argon2id_memlimit_interactive(void)
+{
+    return crypto_pwhash_argon2id_MEMLIMIT_INTERACTIVE;
+}
+
+size_t
+crypto_pwhash_argon2id_opslimit_moderate(void)
+{
+    return crypto_pwhash_argon2id_OPSLIMIT_MODERATE;
+}
+
+size_t
+crypto_pwhash_argon2id_memlimit_moderate(void)
+{
+    return crypto_pwhash_argon2id_MEMLIMIT_MODERATE;
+}
+
+size_t
+crypto_pwhash_argon2id_opslimit_sensitive(void)
+{
+    return crypto_pwhash_argon2id_OPSLIMIT_SENSITIVE;
+}
+
+size_t
+crypto_pwhash_argon2id_memlimit_sensitive(void)
+{
+    return crypto_pwhash_argon2id_MEMLIMIT_SENSITIVE;
+}
+
+int
+crypto_pwhash_argon2id(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)
+{
+    memset(out, 0, outlen);
+    memlimit /= 1024U;
+    if (outlen > ARGON2_MAX_OUTLEN || passwdlen > ARGON2_MAX_PWD_LENGTH ||
+        opslimit > ARGON2_MAX_TIME || memlimit > ARGON2_MAX_MEMORY) {
+        errno = EFBIG;
+        return -1;
+    }
+    if (outlen < ARGON2_MIN_OUTLEN || passwdlen < ARGON2_MIN_PWD_LENGTH ||
+        opslimit < ARGON2_MIN_TIME || memlimit < ARGON2_MIN_MEMORY) {
+        errno = EINVAL;
+        return -1;
+    }
+    switch (alg) {
+    case crypto_pwhash_argon2id_ALG_ARGON2ID13:
+        if (argon2id_hash_raw((uint32_t) opslimit, (uint32_t) memlimit,
+                              (uint32_t) 1U, passwd, (size_t) passwdlen, salt,
+                              (size_t) crypto_pwhash_argon2id_SALTBYTES, out,
+                              (size_t) outlen) != ARGON2_OK) {
+            return -1; /* LCOV_EXCL_LINE */
+        }
+        return 0;
+    default:
+        errno = EINVAL;
+        return -1;
+    }
+}
+
+int
+crypto_pwhash_argon2id_str(char out[crypto_pwhash_argon2id_STRBYTES],
+                           const char *const passwd,
+                           unsigned long long passwdlen,
+                           unsigned long long opslimit, size_t memlimit)
+{
+    unsigned char salt[crypto_pwhash_argon2id_SALTBYTES];
+
+    memset(out, 0, crypto_pwhash_argon2id_STRBYTES);
+    memlimit /= 1024U;
+    if (passwdlen > ARGON2_MAX_PWD_LENGTH || opslimit > ARGON2_MAX_TIME ||
+        memlimit > ARGON2_MAX_MEMORY) {
+        errno = EFBIG;
+        return -1;
+    }
+    if (passwdlen < ARGON2_MIN_PWD_LENGTH || opslimit < ARGON2_MIN_TIME ||
+        memlimit < ARGON2_MIN_MEMORY) {
+        errno = EINVAL;
+        return -1;
+    }
+    randombytes_buf(salt, sizeof salt);
+    if (argon2id_hash_encoded((uint32_t) opslimit, (uint32_t) memlimit,
+                              (uint32_t) 1U, passwd, (size_t) passwdlen, salt,
+                              sizeof salt, STR_HASHBYTES, out,
+                              crypto_pwhash_argon2id_STRBYTES) != ARGON2_OK) {
+        return -1; /* LCOV_EXCL_LINE */
+    }
+    return 0;
+}
+
+int
+crypto_pwhash_argon2id_str_verify(const char str[crypto_pwhash_argon2id_STRBYTES],
+                                  const char *const  passwd,
+                                  unsigned long long passwdlen)
+{
+    int verify_ret;
+
+    if (passwdlen > ARGON2_MAX_PWD_LENGTH) {
+        errno = EFBIG;
+        return -1;
+    }
+    /* LCOV_EXCL_START */
+    if (passwdlen < ARGON2_MIN_PWD_LENGTH) {
+        errno = EINVAL;
+        return -1;
+    }
+    /* LCOV_EXCL_STOP */
+
+    verify_ret = argon2id_verify(str, passwd, (size_t) passwdlen);
+    if (verify_ret == ARGON2_OK) {
+        return 0;
+    }
+    if (verify_ret == ARGON2_VERIFY_MISMATCH) {
+        errno = EINVAL;
+    }
+    return -1;
+}

data/vendor/libsodium/src/libsodium/crypto_pwhash/crypto_pwhash.c

@@ -1,5 +1,6 @@
 
 #include <errno.h>
+#include <string.h>
 
 #include "crypto_pwhash.h"
 
@@ -9,12 +10,42 @@ 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_ARGON2I13;
 }
 
+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)
 {
@@ -33,6 +64,30 @@ 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)
 {
@@ -75,12 +130,15 @@ crypto_pwhash(unsigned char * const out, unsigned long long outlen,
               const unsigned char * const salt,
               unsigned long long opslimit, size_t memlimit, int alg)
 {
-    if (alg != crypto_pwhash_ALG_ARGON2I13) {
+    switch (alg) {
+    case crypto_pwhash_ALG_ARGON2ID13:
+    case crypto_pwhash_ALG_ARGON2I13:
+        return crypto_pwhash_argon2i(out, outlen, passwd, passwdlen, salt,
+                                     opslimit, memlimit, alg);
+    default:
         errno = EINVAL;
         return -1;
     }
-    return crypto_pwhash_argon2i(out, outlen, passwd, passwdlen, salt,
-                                 opslimit, memlimit, alg);
 }
 
 int
@@ -97,7 +155,17 @@ crypto_pwhash_str_verify(const char str[crypto_pwhash_STRBYTES],
                          const char * const passwd,
                          unsigned long long passwdlen)
 {
-    return crypto_pwhash_argon2i_str_verify(str, passwd, 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;
 }
 
 const char *

data/vendor/libsodium/src/libsodium/crypto_pwhash/scryptsalsa208sha256/crypto_scrypt-common.c

@@ -23,14 +23,15 @@
 
 #include "crypto_pwhash_scryptsalsa208sha256.h"
 #include "crypto_scrypt.h"
+#include "private/common.h"
 #include "runtime.h"
 #include "utils.h"
 
-static const char * const itoa64 =
+static const char *const itoa64 =
     "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 
 static uint8_t *
-encode64_uint32(uint8_t * dst, size_t dstlen, uint32_t src, uint32_t srcbits)
+encode64_uint32(uint8_t *dst, size_t dstlen, uint32_t src, uint32_t srcbits)
 {
     uint32_t bit;
 
@@ -42,22 +43,23 @@ encode64_uint32(uint8_t * dst, size_t dstlen, uint32_t src, uint32_t srcbits)
         dstlen--;
         src >>= 6;
     }
-
     return dst;
 }
 
 static uint8_t *
-encode64(uint8_t * dst, size_t dstlen, const uint8_t * src, size_t srclen)
+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;
+    for (i = 0; i < srclen;) {
+        uint8_t *dnext;
         uint32_t value = 0, bits = 0;
+
         do {
-            value |= (uint32_t)src[i++] << bits;
+            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 */
@@ -65,25 +67,25 @@ encode64(uint8_t * dst, size_t dstlen, const uint8_t * src, size_t srclen)
         dstlen -= dnext - dst;
         dst = dnext;
     }
-
     return dst;
 }
 
 static int
-decode64_one(uint32_t * dst, uint8_t src)
+decode64_one(uint32_t *dst, uint8_t src)
 {
     const char *ptr = strchr(itoa64, src);
 
     if (ptr) {
-        *dst = (uint32_t) (ptr - itoa64);
+        *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)
+decode64_uint32(uint32_t *dst, uint32_t dstbits, const uint8_t *src)
 {
     uint32_t bit;
     uint32_t value;
@@ -98,14 +100,14 @@ decode64_uint32(uint32_t * dst, uint32_t dstbits, const uint8_t * src)
         src++;
         value |= one << bit;
     }
-
     *dst = value;
+
     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)
+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;
@@ -142,29 +144,27 @@ escrypt_r(escrypt_local_t * local, const uint8_t * passwd, size_t passwdlen,
     prefixlen = src - setting;
 
     salt = src;
-    src = (uint8_t *) strrchr((char *)salt, '$');
+    src  = (uint8_t *) strrchr((char *) salt, '$');
     if (src) {
         saltlen = src - salt;
     } else {
-        saltlen = strlen((char *)salt);
+        saltlen = strlen((char *) salt);
     }
     need = prefixlen + saltlen + 1 +
-        crypto_pwhash_scryptsalsa208sha256_STRHASHBYTES_ENCODED + 1;
+           crypto_pwhash_scryptsalsa208sha256_STRHASHBYTES_ENCODED + 1;
     if (need > buflen || need < saltlen) {
         return NULL;
     }
-#if defined(HAVE_EMMINTRIN_H) || \
-    (defined(_MSC_VER) && (defined(_M_X64) || defined(_M_AMD64) || defined(_M_IX86)))
+#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))) {
+    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;
@@ -181,24 +181,23 @@ escrypt_r(escrypt_local_t * local, const uint8_t * passwd, size_t passwdlen,
 }
 
 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)
+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;
+    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))) {
+    if (N_log2 > 63 || ((uint64_t) r * (uint64_t) p >= (1U << 30))) {
         return NULL;
     }
-    dst = buf;
+    dst    = buf;
     *dst++ = '$';
     *dst++ = '7';
     *dst++ = '$';
@@ -223,10 +222,10 @@ escrypt_gensalt_r(uint32_t N_log2, uint32_t r, uint32_t p,
 }
 
 int
-crypto_pwhash_scryptsalsa208sha256_ll(const uint8_t * passwd, size_t passwdlen,
-                                      const uint8_t * salt, size_t saltlen,
+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)
+                                      uint8_t *buf, size_t buflen)
 {
     escrypt_kdf_t   escrypt_kdf;
     escrypt_local_t local;
@@ -235,16 +234,14 @@ crypto_pwhash_scryptsalsa208sha256_ll(const uint8_t * passwd, size_t passwdlen,
     if (escrypt_init_local(&local)) {
         return -1; /* LCOV_EXCL_LINE */
     }
-#if defined(HAVE_EMMINTRIN_H) || \
-    (defined(_MSC_VER) && (defined(_M_X64) || defined(_M_AMD64) || defined(_M_IX86)))
+#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);
+    retval = escrypt_kdf(&local, passwd, passwdlen, salt, saltlen, N, r, p, buf,
+                         buflen);
     if (escrypt_free_local(&local)) {
         return -1; /* LCOV_EXCL_LINE */
     }