argon2 0.1.1 → 0.1.2

data/ext/phc-winner-argon2/kats/argon2i.shasum

@@ -1 +1 @@
-d94efacfa5efcdfeb513c829cccda7d9003640e1de64b12fad80f92aad1ab8a4  argon2i
+82ca18d6df38a67b1a52f610f19f1917e5b118014fe31995c83350b92319fa06  argon2i

data/ext/phc-winner-argon2/src/argon2.c

@@ -105,6 +105,61 @@ static const char *Argon2_ErrorMessage[] = {
 {ARGON2_DECODING_FAIL, */ "Decoding failed", /*},*/
 };
 
+
+int argon2_core(argon2_context *context, argon2_type type) {
+    /* 1. Validate all inputs */
+    int result = validate_inputs(context);
+    uint32_t memory_blocks, segment_length;
+    argon2_instance_t instance;
+
+    if (ARGON2_OK != result) {
+        return result;
+    }
+
+    if (Argon2_d != type && Argon2_i != type) {
+        return ARGON2_INCORRECT_TYPE;
+    }
+
+    /* 2. Align memory size */
+    /* Minimum memory_blocks = 8L blocks, where L is the number of lanes */
+    memory_blocks = context->m_cost;
+
+    if (memory_blocks < 2 * ARGON2_SYNC_POINTS * context->lanes) {
+        memory_blocks = 2 * ARGON2_SYNC_POINTS * context->lanes;
+    }
+
+    segment_length = memory_blocks / (context->lanes * ARGON2_SYNC_POINTS);
+    /* Ensure that all segments have equal length */
+    memory_blocks = segment_length * (context->lanes * ARGON2_SYNC_POINTS);
+
+    instance.memory = 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;
+
+    /* 3. Initialization: Hashing inputs, allocating memory, filling first
+     * blocks
+     */
+    result = initialize(&instance, context);
+
+    if (ARGON2_OK != result) {
+        return result;
+    }
+
+    /* 4. Filling memory */
+    fill_memory_blocks(&instance);
+
+    /* 5. Finalization */
+    finalize(context, &instance);
+
+    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,
@@ -311,6 +366,22 @@ int verify_d(argon2_context *context, const char *hash) {
     return 0 == memcmp(hash, context->out, context->outlen);
 }
 
+int verify_i(argon2_context *context, const char *hash) {
+    int result;
+    if (0 == context->outlen || NULL == hash) {
+        return ARGON2_OUT_PTR_MISMATCH;
+    }
+
+    result = argon2_core(context, Argon2_i);
+
+    if (ARGON2_OK != result) {
+        return result;
+    }
+
+    return 0 == memcmp(hash, context->out, context->outlen);
+}
+
+
 const char *error_message(int error_code) {
     enum {
         /* Make sure---at compile time---that the enum size matches the array

data/ext/phc-winner-argon2/src/argon2.h

@@ -194,6 +194,14 @@ typedef struct Argon2_Context {
 /* Argon2 primitive type */
 typedef enum Argon2_type { Argon2_d = 0, Argon2_i = 1 } argon2_type;
 
+
+/*
+ * Function that performs memory-hard hashing with certain degree of parallelism
+ * @param  context  Pointer to the Argon2 internal structure
+ * @return Error code if smth is wrong, ARGON2_OK otherwise
+ */
+int argon2_core(argon2_context *context, argon2_type type);
+
 /**
  * Hashes a password with Argon2i, producing an encoded hash
  * @param t_cost Number of iterations
@@ -319,6 +327,15 @@ int argon2id(argon2_context *context);
  */
 int verify_d(argon2_context *context, const char *hash);
 
+/*
+ * Verify if a given password is correct for Argon2i hashing
+ * @param  context  Pointer to current Argon2 context
+ * @param  hash  The password hash to verify. The length of the hash is
+ * specified by the context outlen member
+ * @return  Zero if successful, a non zero error code otherwise
+ */
+int verify_i(argon2_context *context, const char *hash);
+
 /*
  * Get the associated error message for given error code
  * @return  The error message associated with the given error code

data/ext/phc-winner-argon2/src/blake2/blamka-round-opt.h

@@ -3,11 +3,11 @@
 
 #include "blake2-impl.h"
 
-#if defined(_MSC_VER)
-#include <intrin.h>
+#include <emmintrin.h>
+#if defined(__SSSE3__)
+#include <tmmintrin.h> /* for _mm_shuffle_epi8 and _mm_alignr_epi8 */
 #endif
 
-#include <immintrin.h>
 #if defined(__XOP__) && (defined(__GNUC__) || defined(__clang__))
 #include <x86intrin.h>
 #endif
@@ -134,11 +134,12 @@ static BLAKE2_INLINE __m128i fBlaMka(__m128i x, __m128i y) {
 
 #define UNDIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1)                          \
     do {                                                                       \
-        __m128i t0 = C0;                                                       \
+        __m128i t0, t1;                                                        \
+        t0 = C0;                                                               \
         C0 = C1;                                                               \
         C1 = t0;                                                               \
         t0 = B0;                                                               \
-        __m128i t1 = D0;                                                       \
+        t1 = D0;                                                               \
         B0 = _mm_unpackhi_epi64(B1, _mm_unpacklo_epi64(B0, B0));               \
         B1 = _mm_unpackhi_epi64(t0, _mm_unpacklo_epi64(B1, B1));               \
         D0 = _mm_unpackhi_epi64(D0, _mm_unpacklo_epi64(D1, D1));               \

data/ext/phc-winner-argon2/src/core.c

@@ -54,26 +54,26 @@
 void init_block_value(block *b, uint8_t in) { memset(b->v, in, sizeof(b->v)); }
 
 void copy_block(block *dst, const block *src) {
-    memcpy(dst->v, src->v, sizeof(uint64_t) * ARGON2_WORDS_IN_BLOCK);
+    memcpy(dst->v, src->v, sizeof(uint64_t) * ARGON2_QWORDS_IN_BLOCK);
 }
 
 void xor_block(block *dst, const block *src) {
     int i;
-    for (i = 0; i < ARGON2_WORDS_IN_BLOCK; ++i) {
+    for (i = 0; i < ARGON2_QWORDS_IN_BLOCK; ++i) {
         dst->v[i] ^= src->v[i];
     }
 }
 
 static void load_block(block *dst, const void *input) {
     unsigned i;
-    for (i = 0; i < ARGON2_WORDS_IN_BLOCK; ++i) {
+    for (i = 0; i < ARGON2_QWORDS_IN_BLOCK; ++i) {
         dst->v[i] = load64((const uint8_t *)input + i * sizeof(dst->v[i]));
     }
 }
 
 static void store_block(void *output, const block *src) {
     unsigned i;
-    for (i = 0; i < ARGON2_WORDS_IN_BLOCK; ++i) {
+    for (i = 0; i < ARGON2_QWORDS_IN_BLOCK; ++i) {
         store64((uint8_t *)output + i * sizeof(src->v[i]), src->v[i]);
     }
 }
@@ -424,6 +424,10 @@ int validate_inputs(const argon2_context *context) {
         return ARGON2_MEMORY_TOO_MUCH;
     }
 
+    if (context->m_cost < 8*context->lanes) {
+        return ARGON2_MEMORY_TOO_LITTLE;
+    }
+
     /* Validate time cost */
     if (ARGON2_MIN_TIME > context->t_cost) {
         return ARGON2_TIME_TOO_SMALL;
@@ -606,55 +610,3 @@ int initialize(argon2_instance_t *instance, argon2_context *context) {
     return ARGON2_OK;
 }
 
-int argon2_core(argon2_context *context, argon2_type type) {
-    /* 1. Validate all inputs */
-    int result = validate_inputs(context);
-    uint32_t memory_blocks, segment_length;
-    argon2_instance_t instance;
-
-    if (ARGON2_OK != result) {
-        return result;
-    }
-
-    if (Argon2_d != type && Argon2_i != type) {
-        return ARGON2_INCORRECT_TYPE;
-    }
-
-    /* 2. Align memory size */
-    /* Minimum memory_blocks = 8L blocks, where L is the number of lanes */
-    memory_blocks = context->m_cost;
-
-    if (memory_blocks < 2 * ARGON2_SYNC_POINTS * context->lanes) {
-        memory_blocks = 2 * ARGON2_SYNC_POINTS * context->lanes;
-    }
-
-    segment_length = memory_blocks / (context->lanes * ARGON2_SYNC_POINTS);
-    /* Ensure that all segments have equal length */
-    memory_blocks = segment_length * (context->lanes * ARGON2_SYNC_POINTS);
-
-    instance.memory = 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;
-
-    /* 3. Initialization: Hashing inputs, allocating memory, filling first
-     * blocks
-     */
-    result = initialize(&instance, context);
-
-    if (ARGON2_OK != result) {
-        return result;
-    }
-
-    /* 4. Filling memory */
-    fill_memory_blocks(&instance);
-
-    /* 5. Finalization */
-    finalize(context, &instance);
-
-    return ARGON2_OK;
-}

data/ext/phc-winner-argon2/src/core.h

@@ -33,8 +33,8 @@ enum argon2_core_constants {
 
     /* Memory block size in bytes */
     ARGON2_BLOCK_SIZE = 1024,
-    ARGON2_WORDS_IN_BLOCK = ARGON2_BLOCK_SIZE / 8,
-    ARGON2_QWORDS_IN_BLOCK = 64,
+    ARGON2_QWORDS_IN_BLOCK = ARGON2_BLOCK_SIZE / 8,
+    ARGON2_OWORDS_IN_BLOCK = ARGON2_BLOCK_SIZE / 16,
 
     /* Number of pseudo-random values generated by one call to Blake in Argon2i
        to
@@ -54,7 +54,7 @@ enum argon2_core_constants {
  * Memory blocks can be copied, XORed. Internal words can be accessed by [] (no
  * bounds checking).
  */
-typedef struct _block { uint64_t v[ARGON2_WORDS_IN_BLOCK]; } block;
+typedef struct block_ { uint64_t v[ARGON2_QWORDS_IN_BLOCK]; } block;
 
 /*****************Functions that work with the block******************/
 
@@ -215,11 +215,4 @@ void fill_segment(const argon2_instance_t *instance,
  */
 void fill_memory_blocks(argon2_instance_t *instance);
 
-/*
- * Function that performs memory-hard hashing with certain degree of parallelism
- * @param  context  Pointer to the Argon2 internal structure
- * @return Error code if smth is wrong, ARGON2_OK otherwise
- */
-int argon2_core(argon2_context *context, argon2_type type);
-
 #endif

data/ext/phc-winner-argon2/src/encoding.c

@@ -254,7 +254,7 @@ int decode_string(argon2_context *ctx, const char *str, argon2_type type) {
             return 0;                                                          \
         }                                                                      \
         str += cc_len;                                                         \
-    } while (0)
+    } while ((void)0, 0)
 
 #define CC_opt(prefix, code)                                                   \
     do {                                                                       \
@@ -263,7 +263,7 @@ int decode_string(argon2_context *ctx, const char *str, argon2_type type) {
             str += cc_len;                                                     \
             { code; }                                                          \
         }                                                                      \
-    } while (0)
+    } while ((void)0, 0)
 
 #define DECIMAL(x)                                                             \
     do {                                                                       \
@@ -273,17 +273,17 @@ int decode_string(argon2_context *ctx, const char *str, argon2_type type) {
             return 0;                                                          \
         }                                                                      \
         (x) = dec_x;                                                           \
-    } while (0)
+    } while ((void)0, 0)
 
 #define BIN(buf, max_len, len)                                                 \
     do {                                                                       \
         size_t bin_len = (max_len);                                            \
         str = from_base64(buf, &bin_len, str);                                 \
-        if (str == NULL) {                                                     \
+        if (str == NULL || bin_len > UINT32_MAX) {                             \
             return 0;                                                          \
         }                                                                      \
-        (len) = bin_len;                                                       \
-    } while (0)
+        (len) = (uint32_t)bin_len;                                             \
+    } while ((void)0, 0)
 
     size_t maxadlen = ctx->adlen;
     size_t maxsaltlen = ctx->saltlen;
@@ -379,14 +379,14 @@ int encode_string(char *dst, size_t dst_len, argon2_context *ctx,
         memcpy(dst, str, pp_len + 1);                                          \
         dst += pp_len;                                                         \
         dst_len -= pp_len;                                                     \
-    } while (0)
+    } while ((void)0, 0)
 
 #define SX(x)                                                                  \
     do {                                                                       \
         char tmp[30];                                                          \
         sprintf(tmp, "%lu", (unsigned long)(x));                               \
         SS(tmp);                                                               \
-    } while (0)
+    } while ((void)0, 0)
 
 #define SB(buf, len)                                                           \
     do {                                                                       \
@@ -396,7 +396,7 @@ int encode_string(char *dst, size_t dst_len, argon2_context *ctx,
         }                                                                      \
         dst += sb_len;                                                         \
         dst_len -= sb_len;                                                     \
-    } while (0)
+    } while ((void)0, 0)
 
     if (type == Argon2_i)
         SS("$argon2i$m=");

data/ext/phc-winner-argon2/src/genkat.c

@@ -114,9 +114,9 @@ void internal_kat(const argon2_instance_t *instance, uint32_t pass) {
 
         for (i = 0; i < instance->memory_blocks; ++i) {
             uint32_t how_many_words =
-                (instance->memory_blocks > ARGON2_WORDS_IN_BLOCK)
+                (instance->memory_blocks > ARGON2_QWORDS_IN_BLOCK)
                     ? 1
-                    : ARGON2_WORDS_IN_BLOCK;
+                    : ARGON2_QWORDS_IN_BLOCK;
 
             for (j = 0; j < how_many_words; ++j)
                 printf("Block %.4u [%3u]: %016" PRIx64 "\n", i, j,
@@ -147,7 +147,7 @@ static void generate_testvectors(const char *type) {
     const deallocate_fptr myown_deallocator = NULL;
 
     unsigned t_cost = 3;
-    unsigned m_cost = 16;
+    unsigned m_cost = 32;
     unsigned lanes = 4;
 
     memset(pwd, 1, TEST_OUTLEN);

data/ext/phc-winner-argon2/src/opt.c

@@ -15,8 +15,6 @@
 #include <string.h>
 #include <stdlib.h>
 
-#include <immintrin.h>
-
 #include "argon2.h"
 #include "core.h"
 #include "opt.h"
@@ -25,10 +23,10 @@
 #include "blake2/blamka-round-opt.h"
 
 void fill_block(__m128i *state, const uint8_t *ref_block, uint8_t *next_block) {
-    __m128i block_XY[ARGON2_QWORDS_IN_BLOCK];
+    __m128i block_XY[ARGON2_OWORDS_IN_BLOCK];
     uint32_t i;
 
-    for (i = 0; i < ARGON2_QWORDS_IN_BLOCK; i++) {
+    for (i = 0; i < ARGON2_OWORDS_IN_BLOCK; i++) {
         block_XY[i] = state[i] = _mm_xor_si128(
             state[i], _mm_loadu_si128((__m128i const *)(&ref_block[16 * i])));
     }
@@ -45,7 +43,7 @@ void fill_block(__m128i *state, const uint8_t *ref_block, uint8_t *next_block) {
                      state[8 * 6 + i], state[8 * 7 + i]);
     }
 
-    for (i = 0; i < ARGON2_QWORDS_IN_BLOCK; i++) {
+    for (i = 0; i < ARGON2_OWORDS_IN_BLOCK; i++) {
         state[i] = _mm_xor_si128(state[i], block_XY[i]);
         _mm_storeu_si128((__m128i *)(&next_block[16 * i]), state[i]);
     }
@@ -70,8 +68,8 @@ void generate_addresses(const argon2_instance_t *instance,
 
         for (i = 0; i < instance->segment_length; ++i) {
             if (i % ARGON2_ADDRESSES_IN_BLOCK == 0) {
-                __m128i zero_block[ARGON2_QWORDS_IN_BLOCK];
-                __m128i zero2_block[ARGON2_QWORDS_IN_BLOCK];
+                __m128i zero_block[ARGON2_OWORDS_IN_BLOCK];
+                __m128i zero2_block[ARGON2_OWORDS_IN_BLOCK];
                 memset(zero_block, 0, sizeof(zero_block));
                 memset(zero2_block, 0, sizeof(zero2_block));
                 input_block.v[6]++;

data/ext/phc-winner-argon2/src/opt.h

@@ -14,6 +14,11 @@
 #ifndef ARGON2_OPT_H
 #define ARGON2_OPT_H
 
+#include <stdint.h>
+#include <emmintrin.h>
+#include "argon2.h"
+#include "core.h"
+
 /*
  * Function fills a new memory block. Differs from the
  * @param state Pointer to the just produced block. Content will be updated(!)

data/lib/argon2.rb

@@ -17,10 +17,6 @@ module Argon2
     end
 
     def hash(pass)
-      # It is technically possible to include NULL bytes, however our C
-      # uses strlen(). It is not deemed suitable to accept a user password
-      # with such a character.
-      raise ArgonHashFail, "NULL bytes not permitted" if /\0/.match(pass)
       Argon2::Engine.hash_argon2i_encode(
               pass, @salt, @t_cost, @m_cost, @secret)
     end

data/lib/argon2/ffi_engine.rb

@@ -16,14 +16,16 @@ module Argon2
       :uint, :uint, :uint, :pointer,
       :size_t, :pointer, :size_t, :pointer, :size_t], :int, :blocking => true
 
-    #void argon2_wrap(uint8_t *out, char *pwd, uint8_t *salt, uint32_t t_cost,
+    #void argon2_wrap(uint8_t *out, char *pwd, size_it pwdlen,
+    #uint8_t *salt, uint32_t t_cost,
     #    uint32_t m_cost, uint32_t lanes,
     #    uint8_t *secret, uint32_t secretlen)
     attach_function :argon2_wrap, [
-      :pointer, :pointer, :pointer, :uint,
+      :pointer, :pointer, :size_t, :pointer, :uint,
       :uint, :uint, :pointer, :size_t], :uint, :blocking => true
 
-    #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);
     attach_function :wrap_argon2_verify, [:pointer, :pointer, :size_t,
       :pointer, :size_t], :int, :blocking => true
   end
@@ -46,11 +48,13 @@ module Argon2
     def self.hash_argon2i_encode(password, salt, t_cost, m_cost, secret)
       result = ''
       secretlen = secret.nil? ? 0 : secret.length
+      passwordlen = password.nil? ? 0 : password.length
       if salt.length != Constants::SALT_LEN
         raise ArgonHashFail, "Invalid salt size"
       end
       FFI::MemoryPointer.new(:char, Constants::ENCODE_LEN) do |buffer|
-        ret = Ext.argon2_wrap(buffer, password, salt, t_cost, (1 << m_cost),
+        ret = Ext.argon2_wrap(buffer, password, passwordlen,
+            salt, t_cost, (1 << m_cost),
             1, secret, secretlen)
         raise ArgonHashFail, ERRORS[ret] unless ret == 0
         result = buffer.read_string(Constants::ENCODE_LEN)