rbnacl-libsodium 1.0.11 → 1.0.13

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

@@ -24,9 +24,10 @@ enum argon2_ctx_constants {
     ARGON2_VERSION_NUMBER = 0x13,
 
     /* Memory block size in bytes */
-    ARGON2_BLOCK_SIZE = 1024,
+    ARGON2_BLOCK_SIZE      = 1024,
     ARGON2_QWORDS_IN_BLOCK = ARGON2_BLOCK_SIZE / 8,
     ARGON2_OWORDS_IN_BLOCK = ARGON2_BLOCK_SIZE / 16,
+    ARGON2_HWORDS_IN_BLOCK = ARGON2_BLOCK_SIZE / 32,
 
     /* Number of pseudo-random values generated by one call to Blake in Argon2i
        to
@@ -35,7 +36,7 @@ enum argon2_ctx_constants {
 
     /* Pre-hashing digest length and its extension*/
     ARGON2_PREHASH_DIGEST_LENGTH = 64,
-    ARGON2_PREHASH_SEED_LENGTH = 72
+    ARGON2_PREHASH_SEED_LENGTH   = 72
 };
 
 /*************************Argon2 internal data
@@ -46,10 +47,12 @@ enum argon2_ctx_constants {
  * Memory blocks can be copied, XORed. Internal words can be accessed by [] (no
  * bounds checking).
  */
-typedef struct block_ { uint64_t v[ARGON2_QWORDS_IN_BLOCK]; } block;
+typedef struct block_ {
+    uint64_t v[ARGON2_QWORDS_IN_BLOCK];
+} block;
 
 typedef struct block_region_ {
-    void  *base;
+    void * base;
     block *memory;
     size_t size;
 } block_region;
@@ -72,15 +75,15 @@ void xor_block(block *dst, const block *src);
  * thread
  */
 typedef struct Argon2_instance_t {
-    block_region *region;   /* Memory region pointer */
-    uint32_t passes;        /* Number of passes */
-    uint32_t memory_blocks; /* Number of blocks in memory */
-    uint32_t segment_length;
-    uint32_t lane_length;
-    uint32_t lanes;
-    uint32_t threads;
-    argon2_type type;
-    int print_internals; /* whether to print the memory blocks */
+    block_region *region;        /* Memory region pointer */
+    uint32_t      passes;        /* Number of passes */
+    uint32_t      memory_blocks; /* Number of blocks in memory */
+    uint32_t      segment_length;
+    uint32_t      lane_length;
+    uint32_t      lanes;
+    uint32_t      threads;
+    argon2_type   type;
+    int           print_internals; /* whether to print the memory blocks */
 } argon2_instance_t;
 
 /*
@@ -90,14 +93,14 @@ typedef struct Argon2_instance_t {
 typedef struct Argon2_position_t {
     uint32_t pass;
     uint32_t lane;
-    uint8_t slice;
+    uint8_t  slice;
     uint32_t index;
 } argon2_position_t;
 
 /*Struct that holds the inputs for thread handling FillSegment*/
 typedef struct Argon2_thread_data {
     argon2_instance_t *instance_ptr;
-    argon2_position_t pos;
+    argon2_position_t  pos;
 } argon2_thread_data;
 
 /*************************Argon2 core
@@ -180,12 +183,14 @@ void finalize(const argon2_context *context, argon2_instance_t *instance);
  * @pre all block pointers must be valid
  */
 typedef int (*fill_segment_fn)(const argon2_instance_t *instance,
-                               argon2_position_t position);
+                               argon2_position_t        position);
 int argon2_pick_best_implementation(void);
+int fill_segment_avx2(const argon2_instance_t *instance,
+                      argon2_position_t        position);
 int fill_segment_ssse3(const argon2_instance_t *instance,
-                       argon2_position_t position);
+                       argon2_position_t        position);
 int fill_segment_ref(const argon2_instance_t *instance,
-                     argon2_position_t position);
+                     argon2_position_t        position);
 
 /*
  * Function that fills the entire memory t_cost times based on the first two

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

@@ -1,9 +1,9 @@
+#include "argon2-encoding.h"
+#include "argon2-core.h"
+#include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <limits.h>
-#include "argon2-core.h"
-#include "argon2-encoding.h"
 
 /*
  * Example code for a decoder and encoder of "hash strings", with Argon2
@@ -22,11 +22,6 @@
  *   the parameters, salts and outputs. It does not compute the hash
  *   itself.
  *
- *   -- The third section is test code, with a main() function. With
- *   this section, the whole file compiles as a stand-alone program
- *   that exercises the encoding and decoding functions with some
- *   test vectors.
- *
  * The code was originally written by Thomas Pornin <pornin@bolet.org>,
  * to whom comments and remarks may be sent. It is released under what
  * should amount to Public Domain or its closest equivalent; the
@@ -59,8 +54,9 @@
  * Some macros for constant-time comparisons. These work over values in
  * the 0..255 range. Returned value is 0x00 on "false", 0xFF on "true".
  */
-#define EQ(x, y) ((((0U - ((unsigned)(x) ^ (unsigned)(y))) >> 8) & 0xFF) ^ 0xFF)
-#define GT(x, y) ((((unsigned)(y) - (unsigned)(x)) >> 8) & 0xFF)
+#define EQ(x, y) \
+    ((((0U - ((unsigned) (x) ^ (unsigned) (y))) >> 8) & 0xFF) ^ 0xFF)
+#define GT(x, y) ((((unsigned) (y) - (unsigned) (x)) >> 8) & 0xFF)
 #define GE(x, y) (GT(y, x) ^ 0xFF)
 #define LT(x, y) GT(y, x)
 #define LE(x, y) GE(y, x)
@@ -68,7 +64,9 @@
 /*
  * Convert value x (0..63) to corresponding Base64 character.
  */
-static int b64_byte_to_char(unsigned x) {
+static int
+b64_byte_to_char(unsigned x)
+{
     return (LT(x, 26) & (x + 'A')) |
            (GE(x, 26) & LT(x, 52) & (x + ('a' - 26))) |
            (GE(x, 52) & LT(x, 62) & (x + ('0' - 52))) | (EQ(x, 62) & '+') |
@@ -79,7 +77,9 @@ static int b64_byte_to_char(unsigned x) {
  * Convert character c to the corresponding 6-bit value. If character c
  * is not a Base64 character, then 0xFF (255) is returned.
  */
-static unsigned b64_char_to_byte(int c) {
+static unsigned
+b64_char_to_byte(int c)
+{
     unsigned x;
 
     x = (GE(c, 'A') & LE(c, 'Z') & (c - 'A')) |
@@ -97,11 +97,12 @@ static unsigned b64_char_to_byte(int c) {
  * in the buffer, and the output length (counted WITHOUT the terminating
  * zero) is returned.
  */
-static size_t to_base64(char *dst, size_t dst_len, const void *src,
-                        size_t src_len) {
-    size_t olen;
+static size_t
+to_base64(char *dst, size_t dst_len, const void *src, size_t src_len)
+{
+    size_t               olen;
     const unsigned char *buf;
-    unsigned acc, acc_len;
+    unsigned             acc, acc_len;
 
     olen = (src_len / 3) << 2;
     switch (src_len % 3) {
@@ -113,21 +114,21 @@ static size_t to_base64(char *dst, size_t dst_len, const void *src,
         break;
     }
     if (dst_len <= olen) {
-        return (size_t)-1;
+        return (size_t) -1;
     }
-    acc = 0;
+    acc     = 0;
     acc_len = 0;
-    buf = (const unsigned char *)src;
+    buf     = (const unsigned char *) src;
     while (src_len-- > 0) {
         acc = (acc << 8) + (*buf++);
         acc_len += 8;
         while (acc_len >= 6) {
             acc_len -= 6;
-            *dst++ = (char)b64_byte_to_char((acc >> acc_len) & 0x3F);
+            *dst++ = (char) b64_byte_to_char((acc >> acc_len) & 0x3F);
         }
     }
     if (acc_len > 0) {
-        *dst++ = (char)b64_byte_to_char((acc << (6 - acc_len)) & 0x3F);
+        *dst++ = (char) b64_byte_to_char((acc << (6 - acc_len)) & 0x3F);
     }
     *dst++ = 0;
     return olen;
@@ -146,14 +147,16 @@ static size_t to_base64(char *dst, size_t dst_len, const void *src,
  * points to the first non-Base64 character in the source stream, which
  * may be the terminating zero.
  */
-static const char *from_base64(void *dst, size_t *dst_len, const char *src) {
-    size_t len;
+static const char *
+from_base64(void *dst, size_t *dst_len, const char *src)
+{
+    size_t         len;
     unsigned char *buf;
-    unsigned acc, acc_len;
+    unsigned       acc, acc_len;
 
-    buf = (unsigned char *)dst;
-    len = 0;
-    acc = 0;
+    buf     = (unsigned char *) dst;
+    len     = 0;
+    acc     = 0;
     acc_len = 0;
     for (;;) {
         unsigned d;
@@ -194,9 +197,11 @@ static const char *from_base64(void *dst, size_t *dst_len, const char *src) {
  * minimal (extra leading zeros), or the value does not fit in an
  * 'unsigned long', then NULL is returned.
  */
-static const char *decode_decimal(const char *str, unsigned long *v) {
-    const char *orig;
-    unsigned long acc;
+static const char *
+decode_decimal(const char *str, unsigned long *v)
+{
+    const char    *orig;
+    unsigned long  acc;
 
     acc = 0;
     for (orig = str;; str++) {
@@ -211,10 +216,10 @@ static const char *decode_decimal(const char *str, unsigned long *v) {
             return NULL;
         }
         acc *= 10;
-        if ((unsigned long)c > (ULONG_MAX - acc)) {
+        if ((unsigned long) c > (ULONG_MAX - acc)) {
             return NULL;
         }
-        acc += (unsigned long)c;
+        acc += (unsigned long) c;
     }
     if (str == orig || (*orig == '0' && str != (orig + 1))) {
         return NULL;
@@ -229,103 +234,121 @@ static const char *decode_decimal(const char *str, unsigned long *v) {
  *
  * The code below applies the following format:
  *
- *  $argon2<T>$v=<num>$m=<num>,t=<num>,p=<num>[,keyid=<bin>][,data=<bin>][$<bin>[$<bin>]]
+ *  $argon2<T>[$v=<num>]$m=<num>,t=<num>,p=<num>$<bin>$<bin>
  *
- * where <T> is either 'd' or 'i', <num> is a decimal integer (positive, fits in an 'unsigned long')
- * and <bin> is Base64-encoded data (no '=' padding characters, no newline
- * or whitespace). The "keyid" is a binary identifier for a key (up to 8
- * bytes); "data" is associated data (up to 32 bytes). When the 'keyid'
- * (resp. the 'data') is empty, then it is ommitted from the output.
+ * where <T> is either 'i', <num> is a decimal integer (positive, fits in an
+ * 'unsigned long') and <bin> is Base64-encoded data (no '=' padding characters,
+ * no newline or whitespace).
  *
  * The last two binary chunks (encoded in Base64) are, in that order,
- * the salt and the output. Both are optional, but you cannot have an
- * output without a salt. The binary salt length is between 8 and 48 bytes.
- * The output length is always exactly 32 bytes.
+ * the salt and the output. Both are required. The binary salt length and the
+ * output length must be in the allowed ranges defined in argon2.h.
+ *
+ * The ctx struct must contain buffers large enough to hold the salt and pwd
+ * when it is fed into decode_string.
  */
 
 /*
  * Decode an Argon2i hash string into the provided structure 'ctx'.
  * Returned value is ARGON2_OK on success.
  */
-int decode_string(argon2_context *ctx, const char *str, argon2_type type) {
-    /* Prefix checking */
-#define CC(prefix)                                                             \
-    do {                                                                       \
-        size_t cc_len = strlen(prefix);                                        \
-        if (strncmp(str, prefix, cc_len) != 0) {                               \
-            return ARGON2_DECODING_FAIL;                                       \
-        }                                                                      \
-        str += cc_len;                                                         \
+int
+decode_string(argon2_context *ctx, const char *str, argon2_type type)
+{
+/* Prefix checking */
+#define CC(prefix)                               \
+    do {                                         \
+        size_t cc_len = strlen(prefix);          \
+        if (strncmp(str, prefix, cc_len) != 0) { \
+            return ARGON2_DECODING_FAIL;         \
+        }                                        \
+        str += cc_len;                           \
+    } while ((void) 0, 0)
+
+/* Optional prefix checking with supplied code */
+#define CC_opt(prefix, code)                     \
+    do {                                         \
+        size_t cc_len = strlen(prefix);          \
+        if (strncmp(str, prefix, cc_len) == 0) { \
+            str += cc_len;                       \
+            {                                    \
+                code;                            \
+            }                                    \
+        }                                        \
+    } while ((void) 0, 0)
+
+/* Decoding prefix into decimal */
+#define DECIMAL(x)                         \
+    do {                                   \
+        unsigned long dec_x;               \
+        str = decode_decimal(str, &dec_x); \
+        if (str == NULL) {                 \
+            return ARGON2_DECODING_FAIL;   \
+        }                                  \
+        (x) = dec_x;                       \
+    } while ((void) 0, 0)
+
+/* Decoding prefix into uint32_t decimal */
+#define DECIMAL_U32(x)                           \
+    do {                                         \
+        unsigned long dec_x;                     \
+        str = decode_decimal(str, &dec_x);       \
+        if (str == NULL || dec_x > UINT32_MAX) { \
+            return ARGON2_DECODING_FAIL;         \
+        }                                        \
+        (x) = (uint32_t)dec_x;                   \
     } while ((void)0, 0)
 
-    /* Prefix checking with supplied code */
-#define CC_opt(prefix, code)                                                   \
-    do {                                                                       \
-        size_t cc_len = strlen(prefix);                                        \
-        if (strncmp(str, prefix, cc_len) == 0) {                               \
-            str += cc_len;                                                     \
-            { code; }                                                          \
-        }                                                                      \
-    } while ((void)0, 0)
+/* Decoding base64 into a binary buffer */
+#define BIN(buf, max_len, len)                            \
+    do {                                                  \
+        size_t bin_len = (max_len);                       \
+        str            = from_base64(buf, &bin_len, str); \
+        if (str == NULL || bin_len > UINT32_MAX) {        \
+            return ARGON2_DECODING_FAIL;                  \
+        }                                                 \
+        (len) = (uint32_t) bin_len;                       \
+    } while ((void) 0, 0)
+
+    size_t        maxsaltlen = ctx->saltlen;
+    size_t        maxoutlen  = ctx->outlen;
+    int           validation_result;
+    uint32_t      version = 0;
 
-    /* Decoding prefix into decimal */
-#define DECIMAL(x)                                                             \
-    do {                                                                       \
-        unsigned long dec_x;                                                   \
-        str = decode_decimal(str, &dec_x);                                     \
-        if (str == NULL) {                                                     \
-            return ARGON2_DECODING_FAIL;                                       \
-        }                                                                      \
-        (x) = dec_x;                                                           \
-    } while ((void)0, 0)
-
-    /* Decoding prefix into binary */
-#define BIN(buf, max_len, len)                                                 \
-    do {                                                                       \
-        size_t bin_len = (max_len);                                            \
-        str = from_base64(buf, &bin_len, str);                                 \
-        if (str == NULL || bin_len > UINT32_MAX) {                             \
-            return ARGON2_DECODING_FAIL;                                       \
-        }                                                                      \
-        (len) = (uint32_t)bin_len;                                             \
-    } while ((void)0, 0)
-
-    size_t maxadlen = ctx->adlen;
-    size_t maxsaltlen = ctx->saltlen;
-    size_t maxoutlen = ctx->outlen;
-    unsigned long version = 0;
-    int validation_result;
-
-    ctx->adlen = 0;
     ctx->saltlen = 0;
-    ctx->outlen = 0;
-    if (type == Argon2_i) {
+    ctx->outlen  = 0;
+
+    if (type == Argon2_id) {
+        CC("$argon2id");
+    } else if (type == Argon2_i) {
         CC("$argon2i");
     } else {
         return ARGON2_INCORRECT_TYPE;
     }
     CC("$v=");
-    DECIMAL(version);
+    DECIMAL_U32(version);
     if (version != ARGON2_VERSION_NUMBER) {
         return ARGON2_INCORRECT_TYPE;
     }
     CC("$m=");
-    DECIMAL(ctx->m_cost);
+    DECIMAL_U32(ctx->m_cost);
+    if (ctx->m_cost > UINT32_MAX) {
+        return ARGON2_INCORRECT_TYPE;
+    }
     CC(",t=");
-    DECIMAL(ctx->t_cost);
+    DECIMAL_U32(ctx->t_cost);
+    if (ctx->t_cost > UINT32_MAX) {
+        return ARGON2_INCORRECT_TYPE;
+    }
     CC(",p=");
-    DECIMAL(ctx->lanes);
+    DECIMAL_U32(ctx->lanes);
+    if (ctx->lanes > UINT32_MAX) {
+        return ARGON2_INCORRECT_TYPE;
+    }
     ctx->threads = ctx->lanes;
 
-    CC_opt(",data=", BIN(ctx->ad, maxadlen, ctx->adlen));
-    if (*str == 0) {
-        return ARGON2_OK;
-    }
     CC("$");
     BIN(ctx->salt, maxsaltlen, ctx->saltlen);
-    if (*str == 0) {
-        return ARGON2_OK;
-    }
     CC("$");
     BIN(ctx->out, maxoutlen, ctx->outlen);
     validation_result = validate_inputs(ctx);
@@ -345,7 +368,9 @@ int decode_string(argon2_context *ctx, const char *str, argon2_type type) {
 
 #define U32_STR_MAXSIZE 11U
 
-static void u32_to_string(char *str, uint32_t x) {
+static void
+u32_to_string(char *str, uint32_t x)
+{
     char   tmp[U32_STR_MAXSIZE - 1U];
     size_t i;
 
@@ -370,41 +395,45 @@ static void u32_to_string(char *str, uint32_t x) {
  *
  * On success, ARGON2_OK is returned.
  */
-int encode_string(char *dst, size_t dst_len, argon2_context *ctx,
-                  argon2_type type) {
-#define SS(str)                                                                \
-    do {                                                                       \
-        size_t pp_len = strlen(str);                                           \
-        if (pp_len >= dst_len) {                                               \
-            return ARGON2_ENCODING_FAIL;                                       \
-        }                                                                      \
-        memcpy(dst, str, pp_len + 1);                                          \
-        dst += pp_len;                                                         \
-        dst_len -= pp_len;                                                     \
-    } while ((void)0, 0)
-
-#define SX(x)                                                                  \
-    do {                                                                       \
-        char tmp[U32_STR_MAXSIZE];                                             \
-        u32_to_string(tmp, x);                                                 \
-        SS(tmp);                                                               \
-    } while ((void)0, 0)
-
-#define SB(buf, len)                                                           \
-    do {                                                                       \
-        size_t sb_len = to_base64(dst, dst_len, buf, len);                     \
-        if (sb_len == (size_t)-1) {                                            \
-            return ARGON2_ENCODING_FAIL;                                       \
-        }                                                                      \
-        dst += sb_len;                                                         \
-        dst_len -= sb_len;                                                     \
-    } while ((void)0, 0)
+int
+encode_string(char *dst, size_t dst_len, argon2_context *ctx, argon2_type type)
+{
+#define SS(str)                          \
+    do {                                 \
+        size_t pp_len = strlen(str);     \
+        if (pp_len >= dst_len) {         \
+            return ARGON2_ENCODING_FAIL; \
+        }                                \
+        memcpy(dst, str, pp_len + 1);    \
+        dst += pp_len;                   \
+        dst_len -= pp_len;               \
+    } while ((void) 0, 0)
+
+#define SX(x)                      \
+    do {                           \
+        char tmp[U32_STR_MAXSIZE]; \
+        u32_to_string(tmp, x);     \
+        SS(tmp);                   \
+    } while ((void) 0, 0)
+
+#define SB(buf, len)                                       \
+    do {                                                   \
+        size_t sb_len = to_base64(dst, dst_len, buf, len); \
+        if (sb_len == (size_t) -1) {                       \
+            return ARGON2_ENCODING_FAIL;                   \
+        }                                                  \
+        dst += sb_len;                                     \
+        dst_len -= sb_len;                                 \
+    } while ((void) 0, 0)
 
     int validation_result;
 
-    if (type == Argon2_i) {
-        SS("$argon2i$v=");
-    } else {
+    switch (type) {
+    case Argon2_id:
+        SS("$argon2id$v="); break;
+    case Argon2_i:
+        SS("$argon2i$v="); break;
+    default:
         return ARGON2_ENCODING_FAIL;
     }
     validation_result = validate_inputs(ctx);
@@ -419,20 +448,9 @@ int encode_string(char *dst, size_t dst_len, argon2_context *ctx,
     SS(",p=");
     SX(ctx->lanes);
 
-    if (ctx->adlen > 0) {
-        SS(",data=");
-        SB(ctx->ad, ctx->adlen);
-    }
-
-    if (ctx->saltlen == 0) {
-        return ARGON2_OK;
-    }
     SS("$");
     SB(ctx->salt, ctx->saltlen);
 
-    if (ctx->outlen == 0) {
-        return ARGON2_OK;
-    }
     SS("$");
     SB(ctx->out, ctx->outlen);
     return ARGON2_OK;