rbnacl-libsodium 1.0.11 → 1.0.13

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

@@ -11,29 +11,31 @@
  * <http://creativecommons.org/publicdomain/zero/1.0/>.
  */
 
+#include <limits.h>
 #include <stdint.h>
-#include <string.h>
-#include <stdlib.h>
 #include <stdio.h>
-#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
 
 #include "utils.h"
 
-#include "argon2.h"
-#include "argon2-encoding.h"
 #include "argon2-core.h"
+#include "argon2-encoding.h"
+#include "argon2.h"
 
-int argon2_ctx(argon2_context *context, argon2_type type) {
+int
+argon2_ctx(argon2_context *context, argon2_type type)
+{
     /* 1. Validate all inputs */
-    int result = validate_inputs(context);
-    uint32_t memory_blocks, segment_length;
+    int               result = validate_inputs(context);
+    uint32_t          memory_blocks, segment_length;
     argon2_instance_t instance;
 
     if (ARGON2_OK != result) {
         return result;
     }
 
-    if (Argon2_i != type) {
+    if (type != Argon2_id && type != Argon2_i) {
         return ARGON2_INCORRECT_TYPE;
     }
 
@@ -49,14 +51,14 @@ int argon2_ctx(argon2_context *context, argon2_type type) {
     /* Ensure that all segments have equal length */
     memory_blocks = segment_length * (context->lanes * ARGON2_SYNC_POINTS);
 
-    instance.region = NULL;
-    instance.passes = context->t_cost;
-    instance.memory_blocks = memory_blocks;
+    instance.region         = NULL;
+    instance.passes         = context->t_cost;
+    instance.memory_blocks  = memory_blocks;
     instance.segment_length = segment_length;
-    instance.lane_length = segment_length * ARGON2_SYNC_POINTS;
-    instance.lanes = context->lanes;
-    instance.threads = context->threads;
-    instance.type = type;
+    instance.lane_length    = segment_length * ARGON2_SYNC_POINTS;
+    instance.lanes          = context->lanes;
+    instance.threads        = context->threads;
+    instance.type           = type;
 
     /* 3. Initialization: Hashing inputs, allocating memory, filling first
      * blocks
@@ -80,15 +82,16 @@ int argon2_ctx(argon2_context *context, argon2_type type) {
     return ARGON2_OK;
 }
 
-int argon2_hash(const uint32_t t_cost, const uint32_t m_cost,
-                const uint32_t parallelism, const void *pwd,
-                const size_t pwdlen, const void *salt, const size_t saltlen,
-                void *hash, const size_t hashlen, char *encoded,
-                const size_t encodedlen, argon2_type type) {
-
+int
+argon2_hash(const uint32_t t_cost, const uint32_t m_cost,
+            const uint32_t parallelism, const void *pwd, const size_t pwdlen,
+            const void *salt, const size_t saltlen, void *hash,
+            const size_t hashlen, char *encoded, const size_t encodedlen,
+            argon2_type type)
+{
     argon2_context context;
-    int result;
-    uint8_t *out;
+    int            result;
+    uint8_t       *out;
 
     if (pwdlen > ARGON2_MAX_PWD_LENGTH) {
         return ARGON2_PWD_TOO_LONG;
@@ -107,21 +110,21 @@ int argon2_hash(const uint32_t t_cost, const uint32_t m_cost,
         return ARGON2_MEMORY_ALLOCATION_ERROR;
     }
 
-    context.out = (uint8_t *)out;
-    context.outlen = (uint32_t)hashlen;
-    context.pwd = (uint8_t *)pwd;
-    context.pwdlen = (uint32_t)pwdlen;
-    context.salt = (uint8_t *)salt;
-    context.saltlen = (uint32_t)saltlen;
-    context.secret = NULL;
+    context.out       = (uint8_t *) out;
+    context.outlen    = (uint32_t) hashlen;
+    context.pwd       = (uint8_t *) pwd;
+    context.pwdlen    = (uint32_t) pwdlen;
+    context.salt      = (uint8_t *) salt;
+    context.saltlen   = (uint32_t) saltlen;
+    context.secret    = NULL;
     context.secretlen = 0;
-    context.ad = NULL;
-    context.adlen = 0;
-    context.t_cost = t_cost;
-    context.m_cost = m_cost;
-    context.lanes = parallelism;
-    context.threads = parallelism;
-    context.flags = ARGON2_DEFAULT_FLAGS;
+    context.ad        = NULL;
+    context.adlen     = 0;
+    context.t_cost    = t_cost;
+    context.m_cost    = m_cost;
+    context.lanes     = parallelism;
+    context.threads   = parallelism;
+    context.flags     = ARGON2_DEFAULT_FLAGS;
 
     result = argon2_ctx(&context, type);
 
@@ -152,39 +155,63 @@ int argon2_hash(const uint32_t t_cost, const uint32_t m_cost,
     return ARGON2_OK;
 }
 
-int argon2i_hash_encoded(const uint32_t t_cost, const uint32_t m_cost,
-                         const uint32_t parallelism, const void *pwd,
-                         const size_t pwdlen, const void *salt,
-                         const size_t saltlen, const size_t hashlen,
-                         char *encoded, const size_t encodedlen) {
-
+int
+argon2i_hash_encoded(const uint32_t t_cost, const uint32_t m_cost,
+                     const uint32_t parallelism, const void *pwd,
+                     const size_t pwdlen, const void *salt,
+                     const size_t saltlen, const size_t hashlen, char *encoded,
+                     const size_t encodedlen)
+{
     return argon2_hash(t_cost, m_cost, parallelism, pwd, pwdlen, salt, saltlen,
                        NULL, hashlen, encoded, encodedlen, Argon2_i);
 }
 
-int argon2i_hash_raw(const uint32_t t_cost, const uint32_t m_cost,
-                     const uint32_t parallelism, const void *pwd,
-                     const size_t pwdlen, const void *salt,
-                     const size_t saltlen, void *hash, const size_t hashlen) {
-
+int
+argon2i_hash_raw(const uint32_t t_cost, const uint32_t m_cost,
+                 const uint32_t parallelism, const void *pwd,
+                 const size_t pwdlen, const void *salt, const size_t saltlen,
+                 void *hash, const size_t hashlen)
+{
     return argon2_hash(t_cost, m_cost, parallelism, pwd, pwdlen, salt, saltlen,
                        hash, hashlen, NULL, 0, Argon2_i);
 }
 
-int argon2_verify(const char *encoded, const void *pwd, const size_t pwdlen,
-                  argon2_type type) {
+int
+argon2id_hash_encoded(const uint32_t t_cost, const uint32_t m_cost,
+                      const uint32_t parallelism, const void *pwd,
+                      const size_t pwdlen, const void *salt,
+                      const size_t saltlen, const size_t hashlen, char *encoded,
+                      const size_t encodedlen)
+{
+    return argon2_hash(t_cost, m_cost, parallelism, pwd, pwdlen, salt, saltlen,
+                       NULL, hashlen, encoded, encodedlen, Argon2_id);
+}
+
+int
+argon2id_hash_raw(const uint32_t t_cost, const uint32_t m_cost,
+                  const uint32_t parallelism, const void *pwd,
+                  const size_t pwdlen, const void *salt, const size_t saltlen,
+                  void *hash, const size_t hashlen)
+{
+    return argon2_hash(t_cost, m_cost, parallelism, pwd, pwdlen, salt, saltlen,
+                       hash, hashlen, NULL, 0, Argon2_id);
+}
 
+int
+argon2_verify(const char *encoded, const void *pwd, const size_t pwdlen,
+              argon2_type type)
+{
     argon2_context ctx;
-    uint8_t *out;
-    int decode_result;
-    int ret;
-    size_t encoded_len;
+    uint8_t       *out;
+    int            decode_result;
+    int            ret;
+    size_t         encoded_len;
 
     memset(&ctx, 0, sizeof ctx);
 
-    ctx.pwd = NULL;
-    ctx.pwdlen = 0;
-    ctx.secret = NULL;
+    ctx.pwd       = NULL;
+    ctx.pwdlen    = 0;
+    ctx.secret    = NULL;
     ctx.secretlen = 0;
 
     /* max values, to be updated in decode_string */
@@ -192,13 +219,13 @@ int argon2_verify(const char *encoded, const void *pwd, const size_t pwdlen,
     if (encoded_len > UINT32_MAX) {
         return ARGON2_DECODING_LENGTH_FAIL;
     }
-    ctx.adlen = (uint32_t) encoded_len;
+    ctx.adlen   = (uint32_t) encoded_len;
     ctx.saltlen = (uint32_t) encoded_len;
-    ctx.outlen = (uint32_t) encoded_len;
+    ctx.outlen  = (uint32_t) encoded_len;
 
-    ctx.ad = (uint8_t *) malloc(ctx.adlen);
+    ctx.ad   = (uint8_t *) malloc(ctx.adlen);
     ctx.salt = (uint8_t *) malloc(ctx.saltlen);
-    ctx.out = (uint8_t *) malloc(ctx.outlen);
+    ctx.out  = (uint8_t *) malloc(ctx.outlen);
     if (!ctx.out || !ctx.salt || !ctx.ad) {
         free(ctx.ad);
         free(ctx.salt);
@@ -222,8 +249,8 @@ int argon2_verify(const char *encoded, const void *pwd, const size_t pwdlen,
         return decode_result;
     }
 
-    ret = argon2_hash(ctx.t_cost, ctx.m_cost, ctx.threads, pwd, pwdlen, ctx.salt,
-                      ctx.saltlen, out, ctx.outlen, NULL, 0, type);
+    ret = argon2_hash(ctx.t_cost, ctx.m_cost, ctx.threads, pwd, pwdlen,
+                      ctx.salt, ctx.saltlen, out, ctx.outlen, NULL, 0, type);
 
     free(ctx.ad);
     free(ctx.salt);
@@ -237,6 +264,14 @@ int argon2_verify(const char *encoded, const void *pwd, const size_t pwdlen,
     return ret;
 }
 
-int argon2i_verify(const char *encoded, const void *pwd, const size_t pwdlen) {
+int
+argon2i_verify(const char *encoded, const void *pwd, const size_t pwdlen)
+{
     return argon2_verify(encoded, pwd, pwdlen, Argon2_i);
 }
+
+int
+argon2id_verify(const char *encoded, const void *pwd, const size_t pwdlen)
+{
+    return argon2_verify(encoded, pwd, pwdlen, Argon2_id);
+}

data/vendor/libsodium/src/libsodium/crypto_pwhash/argon2/argon2.h

@@ -6,14 +6,15 @@
  * This work is licensed under a Creative Commons CC0 1.0 License/Waiver.
  *
  * You should have received a copy of the CC0 Public Domain Dedication along
- * with this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
+ * with this software. If not, see
+ * <http://creativecommons.org/publicdomain/zero/1.0/>.
  */
 #ifndef argon2_H
 #define argon2_H
 
-#include <stdint.h>
-#include <stddef.h>
 #include <limits.h>
+#include <stddef.h>
+#include <stdint.h>
 
 /*
  * Argon2 input parameter restrictions
@@ -38,10 +39,11 @@
 #define ARGON2_MIN_MEMORY (2 * ARGON2_SYNC_POINTS) /* 2 blocks per slice */
 
 #define ARGON2_MIN(a, b) ((a) < (b) ? (a) : (b))
-/* Max memory size is half the addressing space, topping at 2^32 blocks (4 TB) */
-#define ARGON2_MAX_MEMORY_BITS                                                 \
+/* Max memory size is half the addressing space, topping at 2^32 blocks (4 TB)
+ */
+#define ARGON2_MAX_MEMORY_BITS \
     ARGON2_MIN(UINT32_C(32), (sizeof(void *) * CHAR_BIT - 10 - 1))
-#define ARGON2_MAX_MEMORY                                                      \
+#define ARGON2_MAX_MEMORY \
     ARGON2_MIN(UINT32_C(0xFFFFFFFF), UINT64_C(1) << ARGON2_MAX_MEMORY_BITS)
 
 /* Minimum and maximum number of passes */
@@ -76,45 +78,45 @@ typedef enum Argon2_ErrorCodes {
     ARGON2_OUTPUT_PTR_NULL = -1,
 
     ARGON2_OUTPUT_TOO_SHORT = -2,
-    ARGON2_OUTPUT_TOO_LONG = -3,
+    ARGON2_OUTPUT_TOO_LONG  = -3,
 
     ARGON2_PWD_TOO_SHORT = -4,
-    ARGON2_PWD_TOO_LONG = -5,
+    ARGON2_PWD_TOO_LONG  = -5,
 
     ARGON2_SALT_TOO_SHORT = -6,
-    ARGON2_SALT_TOO_LONG = -7,
+    ARGON2_SALT_TOO_LONG  = -7,
 
     ARGON2_AD_TOO_SHORT = -8,
-    ARGON2_AD_TOO_LONG = -9,
+    ARGON2_AD_TOO_LONG  = -9,
 
     ARGON2_SECRET_TOO_SHORT = -10,
-    ARGON2_SECRET_TOO_LONG = -11,
+    ARGON2_SECRET_TOO_LONG  = -11,
 
     ARGON2_TIME_TOO_SMALL = -12,
     ARGON2_TIME_TOO_LARGE = -13,
 
     ARGON2_MEMORY_TOO_LITTLE = -14,
-    ARGON2_MEMORY_TOO_MUCH = -15,
+    ARGON2_MEMORY_TOO_MUCH   = -15,
 
-    ARGON2_LANES_TOO_FEW = -16,
+    ARGON2_LANES_TOO_FEW  = -16,
     ARGON2_LANES_TOO_MANY = -17,
 
-    ARGON2_PWD_PTR_MISMATCH = -18,    /* NULL ptr with non-zero length */
-    ARGON2_SALT_PTR_MISMATCH = -19,   /* NULL ptr with non-zero length */
+    ARGON2_PWD_PTR_MISMATCH    = -18, /* NULL ptr with non-zero length */
+    ARGON2_SALT_PTR_MISMATCH   = -19, /* NULL ptr with non-zero length */
     ARGON2_SECRET_PTR_MISMATCH = -20, /* NULL ptr with non-zero length */
-    ARGON2_AD_PTR_MISMATCH = -21,     /* NULL ptr with non-zero length */
+    ARGON2_AD_PTR_MISMATCH     = -21, /* NULL ptr with non-zero length */
 
     ARGON2_MEMORY_ALLOCATION_ERROR = -22,
 
-    ARGON2_FREE_MEMORY_CBK_NULL = -23,
+    ARGON2_FREE_MEMORY_CBK_NULL     = -23,
     ARGON2_ALLOCATE_MEMORY_CBK_NULL = -24,
 
     ARGON2_INCORRECT_PARAMETER = -25,
-    ARGON2_INCORRECT_TYPE = -26,
+    ARGON2_INCORRECT_TYPE      = -26,
 
     ARGON2_OUT_PTR_MISMATCH = -27,
 
-    ARGON2_THREADS_TOO_FEW = -28,
+    ARGON2_THREADS_TOO_FEW  = -28,
     ARGON2_THREADS_TOO_MANY = -29,
 
     ARGON2_MISSING_ARGS = -30,
@@ -148,9 +150,12 @@ typedef enum Argon2_ErrorCodes {
  * are pre-hashed (and thus not needed anymore), and the entire memory
  *****
  * Simplest situation: you have output array out[8], password is stored in
- * pwd[32], salt is stored in salt[16], you do not have keys nor associated data.
- * You need to spend 1 GB of RAM and you run 5 passes of Argon2 with 4 parallel lanes.
- * You want to erase the password, but you're OK with last pass not being erased.
+ * pwd[32], salt is stored in salt[16], you do not have keys nor associated
+ *data.
+ * You need to spend 1 GB of RAM and you run 5 passes of Argon2 with 4 parallel
+ *lanes.
+ * You want to erase the password, but you're OK with last pass not being
+ *erased.
  * You want to use the default memory allocator.
  * Then you initialize:
  * Argon2_Context(out,8,pwd,32,salt,16,NULL,0,NULL,0,5,1<<20,4,4,NULL,NULL,true,false,false,false).
@@ -180,7 +185,7 @@ typedef struct Argon2_Context {
 } argon2_context;
 
 /* Argon2 primitive type */
-typedef enum Argon2_type { Argon2_i = 1 } argon2_type;
+typedef enum Argon2_type { Argon2_i = 1, Argon2_id = 2 } argon2_type;
 
 /*
  * Function that performs memory-hard hashing with certain degree of parallelism
@@ -210,6 +215,27 @@ int argon2i_hash_encoded(const uint32_t t_cost, const uint32_t m_cost,
                          const size_t saltlen, const size_t hashlen,
                          char *encoded, const size_t encodedlen);
 
+/**
+ * Hashes a password with Argon2id, producing an encoded hash
+ * @param t_cost Number of iterations
+ * @param m_cost Sets memory usage to m_cost kibibytes
+ * @param parallelism Number of threads and compute lanes
+ * @param pwd Pointer to password
+ * @param pwdlen Password size in bytes
+ * @param salt Pointer to salt
+ * @param saltlen Salt size in bytes
+ * @param hashlen Desired length of the hash in bytes
+ * @param encoded Buffer where to write the encoded hash
+ * @param encodedlen Size of the buffer (thus max size of the encoded hash)
+ * @pre   Different parallelism levels will give different results
+ * @pre   Returns ARGON2_OK if successful
+ */
+int argon2id_hash_encoded(const uint32_t t_cost, const uint32_t m_cost,
+                          const uint32_t parallelism, const void *pwd,
+                          const size_t pwdlen, const void *salt,
+                          const size_t saltlen, const size_t hashlen,
+                          char *encoded, const size_t encodedlen);
+
 /**
  * Hashes a password with Argon2i, producing a raw hash
  * @param t_cost Number of iterations
@@ -229,6 +255,25 @@ int argon2i_hash_raw(const uint32_t t_cost, const uint32_t m_cost,
                      const size_t pwdlen, const void *salt,
                      const size_t saltlen, void *hash, const size_t hashlen);
 
+/**
+ * Hashes a password with Argon2id, producing a raw hash
+ * @param t_cost Number of iterations
+ * @param m_cost Sets memory usage to m_cost kibibytes
+ * @param parallelism Number of threads and compute lanes
+ * @param pwd Pointer to password
+ * @param pwdlen Password size in bytes
+ * @param salt Pointer to salt
+ * @param saltlen Salt size in bytes
+ * @param hash Buffer where to write the raw hash
+ * @param hashlen Desired length of the hash in bytes
+ * @pre   Different parallelism levels will give different results
+ * @pre   Returns ARGON2_OK if successful
+ */
+int argon2id_hash_raw(const uint32_t t_cost, const uint32_t m_cost,
+                      const uint32_t parallelism, const void *pwd,
+                      const size_t pwdlen, const void *salt,
+                      const size_t saltlen, void *hash, const size_t hashlen);
+
 /* generic function underlying the above ones */
 int argon2_hash(const uint32_t t_cost, const uint32_t m_cost,
                 const uint32_t parallelism, const void *pwd,
@@ -245,6 +290,15 @@ int argon2_hash(const uint32_t t_cost, const uint32_t m_cost,
  */
 int argon2i_verify(const char *encoded, const void *pwd, const size_t pwdlen);
 
+/**
+ * Verifies a password against an encoded string
+ * Encoded string is restricted as in validate_inputs()
+ * @param encoded String encoding parameters, salt, hash
+ * @param pwd Pointer to password
+ * @pre   Returns ARGON2_OK if successful
+ */
+int argon2id_verify(const char *encoded, const void *pwd, const size_t pwdlen);
+
 /* generic function underlying the above ones */
 int argon2_verify(const char *encoded, const void *pwd, const size_t pwdlen,
                   argon2_type type);

data/vendor/libsodium/src/libsodium/crypto_pwhash/argon2/blake2b-long.c

@@ -4,64 +4,63 @@
 #include <string.h>
 
 #include "crypto_generichash_blake2b.h"
-#include "utils.h"
 #include "private/common.h"
+#include "utils.h"
 
-#include "argon2-impl.h"
 #include "blake2b-long.h"
 
-int blake2b_long(void *pout, size_t outlen, const void *in, size_t inlen) {
-    uint8_t *out = (uint8_t *)pout;
+int
+blake2b_long(void *pout, size_t outlen, const void *in, size_t inlen)
+{
+    uint8_t *out = (uint8_t *) pout;
     crypto_generichash_blake2b_state blake_state;
-    uint8_t outlen_bytes[4 /* sizeof(uint32_t) */] = {0};
-    int ret = -1;
+    uint8_t outlen_bytes[4 /* sizeof(uint32_t) */] = { 0 };
+    int     ret = -1;
 
     if (outlen > UINT32_MAX) {
         goto fail; /* LCOV_EXCL_LINE */
     }
 
     /* Ensure little-endian byte order! */
-    STORE32_LE(outlen_bytes, (uint32_t)outlen);
+    STORE32_LE(outlen_bytes, (uint32_t) outlen);
 
-#define TRY(statement)                                                         \
-    do {                                                                       \
-        ret = statement;                                                       \
-        if (ret < 0) {                                                         \
-            goto fail;                                                         \
-        }                                                                      \
-    } while ((void)0, 0)
+#define TRY(statement)   \
+    do {                 \
+        ret = statement; \
+        if (ret < 0) {   \
+            goto fail;   \
+        }                \
+    } while ((void) 0, 0)
 
     if (outlen <= crypto_generichash_blake2b_BYTES_MAX) {
         TRY(crypto_generichash_blake2b_init(&blake_state, NULL, 0U, outlen));
         TRY(crypto_generichash_blake2b_update(&blake_state, outlen_bytes,
                                               sizeof(outlen_bytes)));
-        TRY(crypto_generichash_blake2b_update(&blake_state,
-                                              (const unsigned char *) in,
-                                              inlen));
+        TRY(crypto_generichash_blake2b_update(
+            &blake_state, (const unsigned char *) in, inlen));
         TRY(crypto_generichash_blake2b_final(&blake_state, out, outlen));
     } else {
         uint32_t toproduce;
-        uint8_t out_buffer[crypto_generichash_blake2b_BYTES_MAX];
-        uint8_t in_buffer[crypto_generichash_blake2b_BYTES_MAX];
-        TRY(crypto_generichash_blake2b_init(&blake_state, NULL, 0U,
-                                            crypto_generichash_blake2b_BYTES_MAX));
+        uint8_t  out_buffer[crypto_generichash_blake2b_BYTES_MAX];
+        uint8_t  in_buffer[crypto_generichash_blake2b_BYTES_MAX];
+        TRY(crypto_generichash_blake2b_init(
+            &blake_state, NULL, 0U, crypto_generichash_blake2b_BYTES_MAX));
         TRY(crypto_generichash_blake2b_update(&blake_state, outlen_bytes,
                                               sizeof(outlen_bytes)));
-        TRY(crypto_generichash_blake2b_update(&blake_state,
-                                              (const unsigned char *) in,
-                                              inlen));
-        TRY(crypto_generichash_blake2b_final(&blake_state, out_buffer,
-                                             crypto_generichash_blake2b_BYTES_MAX));
+        TRY(crypto_generichash_blake2b_update(
+            &blake_state, (const unsigned char *) in, inlen));
+        TRY(crypto_generichash_blake2b_final(
+            &blake_state, out_buffer, crypto_generichash_blake2b_BYTES_MAX));
         memcpy(out, out_buffer, crypto_generichash_blake2b_BYTES_MAX / 2);
         out += crypto_generichash_blake2b_BYTES_MAX / 2;
-        toproduce = (uint32_t)outlen - crypto_generichash_blake2b_BYTES_MAX / 2;
+        toproduce =
+            (uint32_t) outlen - crypto_generichash_blake2b_BYTES_MAX / 2;
 
         while (toproduce > crypto_generichash_blake2b_BYTES_MAX) {
             memcpy(in_buffer, out_buffer, crypto_generichash_blake2b_BYTES_MAX);
-            TRY(crypto_generichash_blake2b(out_buffer, crypto_generichash_blake2b_BYTES_MAX,
-                                           in_buffer,
-                                           crypto_generichash_blake2b_BYTES_MAX,
-                                           NULL, 0U));
+            TRY(crypto_generichash_blake2b(
+                out_buffer, crypto_generichash_blake2b_BYTES_MAX, in_buffer,
+                crypto_generichash_blake2b_BYTES_MAX, NULL, 0U));
             memcpy(out, out_buffer, crypto_generichash_blake2b_BYTES_MAX / 2);
             out += crypto_generichash_blake2b_BYTES_MAX / 2;
             toproduce -= crypto_generichash_blake2b_BYTES_MAX / 2;