argon2 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e033ede9fe4ee7af5fb80343fbf6b07a8e5d154d
-  data.tar.gz: a13a0c907078a0ceb7d09e4c73d8839702588bad
+  metadata.gz: a59ac92cbaf98d789372ec5b51337d53be008395
+  data.tar.gz: abd378d5272207160eedb6d8027652ff3ef6930a
 SHA512:
-  metadata.gz: e504a8d8f561768a65672742d27cbba36a3ccfc096ad705e19ecc912d6017b5bf4ce4c1f6283b50886b0e9b18e3e0b49f32943a4eb2618911290d911a7ec45f7
-  data.tar.gz: 73c8082e8a39fbf6147bdc15dbb5c5f1c441c95cbd9d45994e65d7f87d566f04af9d9448f0ef20cdd09462b6c4134a5e960ca5b2fa2212de638bef4fb5e53e39
+  metadata.gz: 55fb89025c32f22c92d140e614461d04c8da2a6e6d0d9c75d80e05b0947c1864a0acebbbde6a52266445dd64dfe89a76bcfd914e54669f8f287b7c8e949c04d2
+  data.tar.gz: dd2698c9e8d5483dc42dc866d9911ac899efdaba3ba32475dfd4673c1a16a4ed42bd518c3f8c623006f8ffb0cbd608d37f6d2a832e96346f60c9589e9f4715d7

data/README.md

@@ -1,8 +1,10 @@
-# Argon2
+# Ruby Argon2 Gem
 
 This Ruby Gem provides FFI bindings, and a simplified interface, to the Argon2 algorithm. [Argon2](https://github.com/P-H-C/phc-winner-argon2) is the official winner of the Password Hashing Competition, a several year project to identify a successor to bcrypt/PBKDF/scrypt methods of securely storing passwords. This is an independant project and not official from the PHC team.
 
-*This gem is now considered a beta release* and at this point is not recommended for production use. It has however moved on to being feature complete and users are encouraged to test this product.
+*This gem is now considered a beta release* and at this point is not recommended for production use. The more detailed advice here, is that it is feature complete, and I do not intend on making backward breaking API changes without bumping the Gem version semantically. There is complete tests and documentation, and I'm working on a project to put this into production.
+
+However, at this point, the reference C library that we pull in is under active development, ([including from myself](https://github.com/P-H-C/phc-winner-argon2/pulls?q=is%3Apr+author%3Atechnion)), and this binding isn't released grade until that is.
 
 
 [![Build Status](https://travis-ci.org/technion/ruby-argon2.svg?branch=master)](https://travis-ci.org/technion/ruby-argon2)
@@ -16,10 +18,12 @@ This project has several key tenants to its design:
 * The reference Argon2 implementation is to be used "unaltered". To ensure compliance wit this goal, and encourage regular updates from upstream, this is implemented as a git submodule, and is intended to stay that way.
 * The FFI interface is kept as slim as possible, with wrapper classes preferred to implementing context structs in FFI
 * Security and maintainability take top priority. This can have an impact on platform support. A PR that contains platform specific code paths is unlikely to be accepted.
+* Tested platforms are MRI Ruby 2.2 and JRuby 9000. No assertions are made on other platforms.
 * Errors from the C interface are raised as Exceptions. There are a lot of exception classes, but they tend to relate to things like very broken input, and code bugs. Calls to this library should generally not require a rescue.
 * Test suits should aim for 100% code coverage.
 * Default work values should not be considered constants. I will increase them from time to time.
 * Not exposing the threads parameter is a design choice. I believe there is significant risk, and minimal gain in using a value other than '1'. Four threads on a four core box completely ties up the entire server to process one user logon. If you want more security, increase m_cost.
+* Many Rubocop errors have been disabled, but any commit should avoid new alerts or demonstrate their necessity.
 
 ## Usage
 
@@ -66,6 +70,9 @@ myhash = argon.hash("A password")
 Argon2::Password.verify_password("A password", myhash, KEY)
 ```
 
+## RubyDocs documentation
+
+[The usual URL](http://www.rubydoc.info/gems/argon2) will provide detailed documentation.
 
 ## FAQ
 ### Don't roll your own crypto!

data/ext/argon2_wrap/Makefile

@@ -9,7 +9,6 @@
 #
 
 DIST_SRC = ../phc-winner-argon2/src
-CC = gcc
 SRC = $(DIST_SRC)/argon2.c $(DIST_SRC)/core.c $(DIST_SRC)/blake2/blake2b.c $(DIST_SRC)/thread.c $(DIST_SRC)/encoding.c argon_wrap.c
 OBJ = $(SRC:.c=.o)
 

data/ext/argon2_wrap/test.c

@@ -78,6 +78,7 @@ int main()
 
 #define RAWTEST(T, M, P, PWD, REF) \
     pwd = strdup(PWD); \
+    assert(pwd); \
     ret = argon2i_hash_raw(T, 1<<M, P, pwd, strlen(pwd), salt, SALT_LEN, out, OUT_LEN); \
     assert(ret == ARGON2_OK); \
     for(i=0; i<OUT_LEN; ++i ) \

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

@@ -130,6 +130,9 @@ int argon2_hash(const uint32_t t_cost, const uint32_t m_cost,
     }
 
     out = malloc(hashlen);
+    if (!out) {
+        return ARGON2_MEMORY_ALLOCATION_ERROR;
+    }
 
     context.out = (uint8_t *)out;
     context.outlen = (uint32_t)hashlen;
@@ -230,6 +233,7 @@ int argon2_verify(const char *encoded, const void *pwd, const size_t pwdlen,
 
     argon2_context ctx;
     uint8_t *out;
+    int ret;
 
     /* max values, to be updated in decode_string */
     ctx.adlen = 512;
@@ -239,17 +243,35 @@ int argon2_verify(const char *encoded, const void *pwd, const size_t pwdlen,
     ctx.ad = malloc(ctx.adlen);
     ctx.salt = malloc(ctx.saltlen);
     ctx.out = malloc(ctx.outlen);
+    if (!ctx.out || !ctx.salt || !ctx.ad) {
+        free(ctx.ad);
+        free(ctx.salt);
+        free(ctx.out);
+        return ARGON2_MEMORY_ALLOCATION_ERROR;
+    }
     out = malloc(ctx.outlen);
+    if (!out) {
+        free(ctx.ad);
+        free(ctx.salt);
+        free(ctx.out);
+        return ARGON2_MEMORY_ALLOCATION_ERROR;
+    }
 
-    decode_string(&ctx, encoded, type);
+    if(decode_string(&ctx, encoded, type) != 1) {
+        free(ctx.ad);
+        free(ctx.salt);
+        free(ctx.out);
+        free(out);
+        return ARGON2_DECODING_FAIL;
+    }
 
-    argon2_hash(ctx.t_cost, ctx.m_cost, ctx.threads, pwd, pwdlen, ctx.salt,
+    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);
 
-    if (argon2_compare(out, ctx.out, ctx.outlen)) {
+    if (ret != ARGON2_OK || argon2_compare(out, ctx.out, ctx.outlen)) {
         free(out);
         free(ctx.out);
         return ARGON2_DECODING_FAIL;

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

@@ -361,8 +361,7 @@ int validate_inputs(const argon2_context *context) {
             return ARGON2_PWD_PTR_MISMATCH;
         }
     } else {
-        if (ARGON2_MIN_PWD_LENGTH != 0 && /* TODO: Is this condition right? */
-            ARGON2_MIN_PWD_LENGTH > context->pwdlen) {
+        if (ARGON2_MIN_PWD_LENGTH > context->pwdlen) {
             return ARGON2_PWD_TOO_SHORT;
         }
 

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

@@ -171,7 +171,7 @@ void initial_hash(uint8_t *blockhash, argon2_context *context,
  * @param blockhash Pointer to the pre-hashing digest
  * @pre blockhash must point to @a PREHASH_SEED_LENGTH allocated values
  */
-void fill_firsts_blocks(uint8_t *blockhash, const argon2_instance_t *instance);
+void fill_first_blocks(uint8_t *blockhash, const argon2_instance_t *instance);
 
 /*
  * Function allocates memory, hashes the inputs with Blake,  and creates first

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

@@ -58,7 +58,7 @@
  * 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) ((((-((unsigned)(x) ^ (unsigned)(y))) >> 8) & 0xFF) ^ 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)
@@ -122,11 +122,11 @@ static size_t to_base64(char *dst, size_t dst_len, const void *src,
         acc_len += 8;
         while (acc_len >= 6) {
             acc_len -= 6;
-            *dst++ = b64_byte_to_char((acc >> acc_len) & 0x3F);
+            *dst++ = (char) b64_byte_to_char((acc >> acc_len) & 0x3F);
         }
     }
     if (acc_len > 0) {
-        *dst++ = b64_byte_to_char((acc << (6 - acc_len)) & 0x3F);
+        *dst++ = (char) b64_byte_to_char((acc << (6 - acc_len)) & 0x3F);
     }
     *dst++ = 0;
     return olen;
@@ -197,7 +197,6 @@ static const char *decode_decimal(const char *str, unsigned long *v) {
     const char *orig;
     unsigned long acc;
 
-    orig = str;
     acc = 0;
     for (orig = str;; str++) {
         int c;
@@ -387,7 +386,7 @@ int encode_string(char *dst, size_t dst_len, argon2_context *ctx,
         char tmp[30];                                                          \
         sprintf(tmp, "%lu", (unsigned long)(x));                               \
         SS(tmp);                                                               \
-    } while (0);
+    } while (0)
 
 #define SB(buf, len)                                                           \
     do {                                                                       \
@@ -397,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 (0)
 
     if (type == Argon2_i)
         SS("$argon2i$m=");

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

@@ -1,7 +1,10 @@
-
+#ifndef ENCODING_H
+#define ENCODING_H
 #include "argon2.h"
 
 int encode_string(char *dst, size_t dst_len, argon2_context *ctx,
                   argon2_type type);
 
 int decode_string(argon2_context *ctx, const char *str, argon2_type type);
+
+#endif

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

@@ -27,6 +27,22 @@
 #define THREADS_DEF 1
 #define OUT_LEN 32
 #define SALT_LEN 16
+/* Sample encode: $argon2i$m=65536,t=2,p=4$c29tZXNhbHQAAAAAAAAAAA$QWLzI4TY9HkL2ZTLc8g6SinwdhZewYrzz9zxCo0bkGY
+ * Maximumum lengths are defined as:
+ * strlen $argon2i$ = 9
+ * m=65536 with strlen (uint32_t)-1 = 10, so this total is 12
+ * ,t=2,p=4 If we consider each number to potentially reach four digits in future, this = 14
+ * $c29tZXNhbHQAAAAAAAAAAA Formula for this is (SALT_LEN * 4 + 3) / 3 + 1 = 23
+ * $QWLzI4TY9HkL2ZTLc8g6SinwdhZewYrzz9zxCo0bkGY per above formula, = 44
+ * + NULL byte
+ * 9 + 12 + 14 + 23 + 44 + 1 = 103
+ * Rounded to 4 byte boundary: 104
+ *
+ * WARNING: 104 is only for the parameters supported by this
+   command-line utility. You'll need a longer ENCODED_LEN to support
+   longer salts and ouputs, as supported by the argon2 library
+ */
+#define ENCODED_LEN 108
 
 #define UNUSED_PARAMETER(x) (void)(x)
 
@@ -67,8 +83,8 @@ static void run(uint8_t *out, char *pwd, uint8_t *salt, uint32_t t_cost,
                 uint32_t m_cost, uint32_t lanes, uint32_t threads,
                 argon2_type type) {
     clock_t start_time, stop_time;
-    unsigned pwdlen;
-    char encoded[300];
+    size_t pwdlen;
+    char encoded[ENCODED_LEN];
     uint32_t i;
     int result;
 

data/lib/argon2/version.rb

@@ -1,4 +1,4 @@
 # Standard Gem version constant.
 module Argon2
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: argon2
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Technion
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-11-10 00:00:00.000000000 Z
+date: 2015-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi