argon2 1.1.5 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9425c5c639ac3e940ffffe3f9baa5967976ad2caa49d0716db0de43aa6d41b66
-  data.tar.gz: 607eff42d6c915f2528d5e61f95d264bdace086515a250188e0f937397b684b1
+  metadata.gz: a86e0210b4205a94242bc1afce3a43753cf24ae2c262274d48c3bdb9475c03b8
+  data.tar.gz: 52aa12dec68ee57751a0752fb502441adc37488bf1bfcfe6ebd8250a128dd9c3
 SHA512:
-  metadata.gz: 60b5ff68f0e29fa1c40dc2e9a10e21f585dacd1d95af4a219166be38e9b2734d8bcae85010245ceb5a2d8782f8f65906bce4f951159eaf5bd1e9b8bccd98cf71
-  data.tar.gz: e8d1074c9ad878cb2a7b7e3791b377f0fbf573ead9d9432ad178d1e4c4af4de80d337455d7fb438fd0e5ad15e2bcfa0f5091254674b7c5d45145ac8ce9e5f6e1
+  metadata.gz: bbd74370319320e2b84d6e5ad84f95c512f4d6d7d43ebf804837f47a8073c39d83e0dac72d21dc92586318ee03fc433e651b8ebc670556a6e9ff026ee66647e3
+  data.tar.gz: 96549bceabc5a7c764afeccd07b937080e9a47fbf9c93c78b34d6d6af60da6eeb6a8a027be0534d44afff4e1af1e59efa50d225c0842efa24156ec1c319d3a6b

data/Changelog.md

@@ -1,3 +1,6 @@
+## v1.2.0: 2018-11-29
+- Support for verifying Argon2id format
+
 ## v1.1.5: 2018-04-30
 - Documentation updates
 - Pulled latest reference

data/README.md

@@ -58,6 +58,13 @@ You can then use this function to verify a password against a given hash. Will r
 Argon2::Password.verify_password("password", secure_password)
 ```
 
+Version 1.2.x will now allow verifying an Argon2id password:
+
+```ruby
+Argon2::Password.verify_password("password", "$argon2id$v=19$m=262144,t=2,p=1$c29tZXNhbHQ$eP4eyR+zqlZX1y5xCFTkw9m5GYx0L5YWwvCFvtlbLow")
+  => true
+```
+
 Argon2 supports an optional key value. This should be stored securely on your server, such as alongside your database credentials. Hashes generated with a key will only validate when presented that key.
 
 ```ruby

data/ext/argon2_wrap/argon_wrap.c

@@ -35,7 +35,8 @@ static int wrap_compare(const uint8_t *b1, const uint8_t *b2, size_t len) {
 
 int argon2_wrap_version(char *out, const char *pwd, size_t pwd_length,
         uint8_t *salt,  uint32_t saltlen, uint32_t t_cost, uint32_t m_cost, 
-        uint32_t lanes, uint8_t *secret, size_t secretlen, uint32_t version)
+        uint32_t lanes, uint8_t *secret, size_t secretlen, uint32_t version,
+        argon2_type type)
 {
     uint8_t hash[OUT_LEN];
     argon2_context context;
@@ -67,11 +68,20 @@ int argon2_wrap_version(char *out, const char *pwd, size_t pwd_length,
     context.flags = 0;
     context.version = version;
 
-    int result = argon2i_ctx(&context);
+    int result;
+    if (type == Argon2_i) {
+        result = argon2i_ctx(&context);
+    }  else if (type == Argon2_id) {
+        result = argon2id_ctx(&context);
+    } else {
+        // Unsupported type
+        return ARGON2_ENCODING_FAIL;
+    }
+
     if (result != ARGON2_OK)
         return result;
 
-    encode_string(out, ENCODE_LEN + saltlen, &context, Argon2_i);
+    encode_string(out, ENCODE_LEN + saltlen, &context, type);
     return ARGON2_OK;
 }
  
@@ -83,7 +93,7 @@ int argon2_wrap(char *out, const char *pwd, size_t pwd_length,
         uint32_t lanes, uint8_t *secret, size_t secretlen)
 {
     return argon2_wrap_version(out, pwd, pwd_length, salt, saltlen,
-            t_cost, m_cost, lanes, secret, secretlen, ARGON2_VERSION_13);
+            t_cost, m_cost, lanes, secret, secretlen, ARGON2_VERSION_13, Argon2_i);
 }
 
 int wrap_argon2_verify(const char *encoded, const char *pwd,
@@ -95,6 +105,7 @@ int wrap_argon2_verify(const char *encoded, const char *pwd,
     char *out;
     memset(&ctx, 0, sizeof(argon2_context));
     size_t encoded_len;
+    argon2_type type;
     
     encoded_len = strlen(encoded);
     /* larger than max possible values */
@@ -109,7 +120,16 @@ int wrap_argon2_verify(const char *encoded, const char *pwd,
         return ARGON2_MEMORY_ALLOCATION_ERROR;
     }
 
-    if(decode_string(&ctx, encoded, Argon2_i) != ARGON2_OK) {
+    if (memcmp(encoded, "$argon2id", strlen("$argon2id")) == 0) {
+        type = Argon2_id;
+    } else if (memcmp(encoded, "$argon2i", strlen("$argon2i")) == 0) {
+        type = Argon2_i;
+    } else {
+        // Other types not yet supported
+        return ARGON2_DECODING_FAIL;
+    }
+
+    if (decode_string(&ctx, encoded, type) != ARGON2_OK) {
         free(ctx.salt);
         free(ctx.out);
         return ARGON2_DECODING_FAIL;
@@ -124,7 +144,7 @@ int wrap_argon2_verify(const char *encoded, const char *pwd,
 
     ret = argon2_wrap_version(out, pwd, pwdlen, ctx.salt, ctx.saltlen,
             ctx.t_cost, ctx.m_cost, ctx.lanes, secret, secretlen,
-            ctx.version);
+            ctx.version, type);
 
     free(ctx.salt);
 

data/ext/argon2_wrap/test.c

@@ -99,7 +99,12 @@ int main()
     ret = wrap_argon2_verify("$argon2i$v=19$m=256,t=2,p=1$c29tZXNhbHQAAAAAAAAAAA$3+v51OrdaFn0zGqbsgBD/Z2n4eNr2s27BcpWn0Yyafg", "password",
             strlen("password"), NULL, 0);
     assert(ret == ARGON2_OK);
-    printf("Verify OK test: PASS\n");
+    printf("Verify OK test i variant: PASS\n");
+
+    ret = wrap_argon2_verify("$argon2id$v=19$m=65536,t=2,p=1$c29tZXNhbHQ$CTFhFdXPJO1aFaMaO6Mm5c8y7cJHAph8ArZWb2GRPPc", "password",
+            strlen("password"), NULL, 0);
+    assert(ret == ARGON2_OK);
+    printf("Verify OK test id variant: PASS\n");
 
     ret = wrap_argon2_verify("$argon2i$v=19$m=65536,t=2,p=1$c29tZXNhbHQAAAAAAAAAAA$iUr0/y4tJvPOFfd6fhwl20W04gQ56ZYXcroZnK3bAB4", "notpassword",
             strlen("notpassword"), NULL, 0);

data/ext/phc-winner-argon2/.gitignore

@@ -1,6 +1,6 @@
 argon2
 libargon2.a
-libargon2.so
+libargon2.so*
 libargon2.dylib
 .DS_Store
 src/*.o

data/ext/phc-winner-argon2/.travis.yml

@@ -8,6 +8,17 @@ os:
   - linux
   - osx
 
+# Clang on Linux needs to run in a VM to use ASAN.
+# See: https://github.com/travis-ci/travis-ci/issues/9033
+matrix:
+  exclude:
+    - compiler: clang
+      os: linux
+  include:
+    - compiler: clang
+      os: linux
+      sudo: true
+
 script: make && make testci
 
 after_success:

data/ext/phc-winner-argon2/README.md

@@ -191,9 +191,9 @@ int main(void)
 }
 ```
 
-To use Argon2d instead of Argon2i call `argon2d_hash` instead of
-`argon2i_hash` using the high-level API, and `argon2d` instead of
-`argon2i` using the low-level API. Similarly for Argon2id, call `argond2id_hash`
+To use Argon2d instead of Argon2i call `argon2d_hash_raw` instead of
+`argon2i_hash_raw` using the high-level API, and `argon2d` instead of
+`argon2i` using the low-level API. Similarly for Argon2id, call `argon2id_hash_raw`
 and `argon2id`.
 
 To produce the crypt-like encoding rather than the raw hash, call
@@ -244,13 +244,15 @@ Bindings are available for the following languages (make sure to read
 their documentation):
 
 * [Elixir](https://github.com/riverrun/argon2_elixir) by [@riverrun](https://github.com/riverrun)
+* [Erlang](https://github.com/ergenius/eargon2) by [@ergenius](https://github.com/ergenius)
 * [Go](https://github.com/tvdburgt/go-argon2) by [@tvdburgt](https://github.com/tvdburgt)
-* [Haskell](https://hackage.haskell.org/package/argon2-1.0.0/docs/Crypto-Argon2.html) by [@ocharles](https://github.com/ocharles)
+* [Haskell](https://hackage.haskell.org/package/argon2) by [@hvr](https://github.com/hvr)
 * [JavaScript (native)](https://github.com/ranisalt/node-argon2), by [@ranisalt](https://github.com/ranisalt)
 * [JavaScript (native)](https://github.com/jdconley/argon2themax), by [@jdconley](https://github.com/jdconley)
 * [JavaScript (ffi)](https://github.com/cjlarose/argon2-ffi), by [@cjlarose](https://github.com/cjlarose)
 * [JavaScript (browser)](https://github.com/antelle/argon2-browser), by [@antelle](https://github.com/antelle)
 * [JVM](https://github.com/phxql/argon2-jvm) by [@phXql](https://github.com/phxql)
+* [JVM (with keyed hashing)](https://github.com/kosprov/jargon2-api) by [@kosprov](https://github.com/kosprov)
 * [Lua (native)](https://github.com/thibaultCha/lua-argon2) by [@thibaultCha](https://github.com/thibaultCha)
 * [Lua (ffi)](https://github.com/thibaultCha/lua-argon2-ffi) by [@thibaultCha](https://github.com/thibaultCha)
 * [OCaml](https://github.com/Khady/ocaml-argon2) by [@Khady](https://github.com/Khady)
@@ -260,6 +262,7 @@ their documentation):
 * [R](https://cran.r-project.org/package=argon2) by [@wrathematics](https://github.com/wrathematics)
 * [Ruby](https://github.com/technion/ruby-argon2) by [@technion](https://github.com/technion)
 * [Rust](https://github.com/quininer/argon2-rs) by [@quininer](https://github.com/quininer)
+* [Rust](https://docs.rs/argonautica/) by [@bcmyers](https://github.com/bcmyers/)
 * [C#/.NET CoreCLR](https://github.com/kmaragon/Konscious.Security.Cryptography) by [@kmaragon](https://github.com/kmaragon)
 * [Perl](https://github.com/Leont/crypt-argon2) by [@leont](https://github.com/Leont)
 * [mruby](https://github.com/Asmod4n/mruby-argon2) by [@Asmod4n](https://github.com/Asmod4n)

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

@@ -93,7 +93,7 @@ extern "C" {
 #define ARGON2_FLAG_CLEAR_SECRET (UINT32_C(1) << 1)
 
 /* Global flag to determine if we are wiping internal memory buffers. This flag
- * is defined in core.c and deafults to 1 (wipe internal memory). */
+ * is defined in core.c and defaults to 1 (wipe internal memory). */
 extern int FLAG_clear_internal_memory;
 
 /* Error codes */

data/ext/phc-winner-argon2/latex/argon2-specs.tex

@@ -749,7 +749,7 @@ the vast majority of the users would prefer as few parameters as possible.
 \section{Performance}
 
 \subsection{x86 architecture}
-To optimize the data load and store from/to memory, the memory that will be processed has to be alligned on 16-byte boundary when loaded/stored into/from 128-bit registers and on 32-byte boundary when loaded/stored into/from 256-bit registers. If the memory is not aligned on the specified boundaries, then each memory operation may take one extra CPU cycle, which may cause consistent penalties for many memory accesses.
+To optimize the data load and store from/to memory, the memory that will be processed has to be aligned on 16-byte boundary when loaded/stored into/from 128-bit registers and on 32-byte boundary when loaded/stored into/from 256-bit registers. If the memory is not aligned on the specified boundaries, then each memory operation may take one extra CPU cycle, which may cause consistent penalties for many memory accesses.
 
 
 The results presented are obtained using the \texttt{gcc 4.8.2} compiler  with the following options: \texttt{-m64 -mavx -std=c++11 -pthread -O3}.

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

@@ -18,6 +18,8 @@
 #ifndef ARGON2_KAT_H
 #define ARGON2_KAT_H
 
+#include "core.h"
+
 /*
  * Initial KAT function that prints the inputs to the file
  * @param  blockhash  Array that contains pre-hashing digest

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

@@ -35,7 +35,7 @@
  */
 
 void hashtest(uint32_t version, uint32_t t, uint32_t m, uint32_t p, char *pwd,
-              char *salt, char *hexref, char *mcfref) {
+              char *salt, char *hexref, char *mcfref, argon2_type type) {
     unsigned char out[OUT_LEN];
     unsigned char hex_out[OUT_LEN * 2 + 4];
     char encoded[ENCODED_LEN];
@@ -45,21 +45,20 @@ void hashtest(uint32_t version, uint32_t t, uint32_t m, uint32_t p, char *pwd,
            t, m, p, pwd, salt);
 
     ret = argon2_hash(t, 1 << m, p, pwd, strlen(pwd), salt, strlen(salt), out,
-                      OUT_LEN, encoded, ENCODED_LEN, Argon2_i, version);
+                      OUT_LEN, encoded, ENCODED_LEN, type, version);
     assert(ret == ARGON2_OK);
 
     for (i = 0; i < OUT_LEN; ++i)
         sprintf((char *)(hex_out + i * 2), "%02x", out[i]);
-
     assert(memcmp(hex_out, hexref, OUT_LEN * 2) == 0);
 
     if (ARGON2_VERSION_NUMBER == version) {
         assert(memcmp(encoded, mcfref, strlen(mcfref)) == 0);
     }
 
-    ret = argon2_verify(encoded, pwd, strlen(pwd), Argon2_i);
+    ret = argon2_verify(encoded, pwd, strlen(pwd), type);
     assert(ret == ARGON2_OK);
-    ret = argon2_verify(mcfref, pwd, strlen(pwd), Argon2_i);
+    ret = argon2_verify(mcfref, pwd, strlen(pwd), type);
     assert(ret == ARGON2_OK);
 
     printf("PASS\n");
@@ -78,41 +77,41 @@ int main() {
     hashtest(version, 2, 16, 1, "password", "somesalt",
              "f6c4db4a54e2a370627aff3db6176b94a2a209a62c8e36152711802f7b30c694",
              "$argon2i$m=65536,t=2,p=1$c29tZXNhbHQ"
-             "$9sTbSlTio3Biev89thdrlKKiCaYsjjYVJxGAL3swxpQ");
+             "$9sTbSlTio3Biev89thdrlKKiCaYsjjYVJxGAL3swxpQ", Argon2_i);
 #ifdef TEST_LARGE_RAM
     hashtest(version, 2, 20, 1, "password", "somesalt",
             "9690ec55d28d3ed32562f2e73ea62b02b018757643a2ae6e79528459de8106e9",
             "$argon2i$m=1048576,t=2,p=1$c29tZXNhbHQ"
-            "$lpDsVdKNPtMlYvLnPqYrArAYdXZDoq5ueVKEWd6BBuk");
+            "$lpDsVdKNPtMlYvLnPqYrArAYdXZDoq5ueVKEWd6BBuk", Argon2_i);
 #endif
     hashtest(version, 2, 18, 1, "password", "somesalt",
              "3e689aaa3d28a77cf2bc72a51ac53166761751182f1ee292e3f677a7da4c2467",
              "$argon2i$m=262144,t=2,p=1$c29tZXNhbHQ"
-             "$Pmiaqj0op3zyvHKlGsUxZnYXURgvHuKS4/Z3p9pMJGc");
+             "$Pmiaqj0op3zyvHKlGsUxZnYXURgvHuKS4/Z3p9pMJGc", Argon2_i);
     hashtest(version, 2, 8, 1, "password", "somesalt",
              "fd4dd83d762c49bdeaf57c47bdcd0c2f1babf863fdeb490df63ede9975fccf06",
              "$argon2i$m=256,t=2,p=1$c29tZXNhbHQ"
-             "$/U3YPXYsSb3q9XxHvc0MLxur+GP960kN9j7emXX8zwY");
+             "$/U3YPXYsSb3q9XxHvc0MLxur+GP960kN9j7emXX8zwY", Argon2_i);
     hashtest(version, 2, 8, 2, "password", "somesalt",
              "b6c11560a6a9d61eac706b79a2f97d68b4463aa3ad87e00c07e2b01e90c564fb",
              "$argon2i$m=256,t=2,p=2$c29tZXNhbHQ"
-             "$tsEVYKap1h6scGt5ovl9aLRGOqOth+AMB+KwHpDFZPs");
+             "$tsEVYKap1h6scGt5ovl9aLRGOqOth+AMB+KwHpDFZPs", Argon2_i);
     hashtest(version, 1, 16, 1, "password", "somesalt",
              "81630552b8f3b1f48cdb1992c4c678643d490b2b5eb4ff6c4b3438b5621724b2",
              "$argon2i$m=65536,t=1,p=1$c29tZXNhbHQ"
-             "$gWMFUrjzsfSM2xmSxMZ4ZD1JCytetP9sSzQ4tWIXJLI");
+             "$gWMFUrjzsfSM2xmSxMZ4ZD1JCytetP9sSzQ4tWIXJLI", Argon2_i);
     hashtest(version, 4, 16, 1, "password", "somesalt",
              "f212f01615e6eb5d74734dc3ef40ade2d51d052468d8c69440a3a1f2c1c2847b",
              "$argon2i$m=65536,t=4,p=1$c29tZXNhbHQ"
-             "$8hLwFhXm6110c03D70Ct4tUdBSRo2MaUQKOh8sHChHs");
+             "$8hLwFhXm6110c03D70Ct4tUdBSRo2MaUQKOh8sHChHs", Argon2_i);
     hashtest(version, 2, 16, 1, "differentpassword", "somesalt",
              "e9c902074b6754531a3a0be519e5baf404b30ce69b3f01ac3bf21229960109a3",
              "$argon2i$m=65536,t=2,p=1$c29tZXNhbHQ"
-             "$6ckCB0tnVFMaOgvlGeW69ASzDOabPwGsO/ISKZYBCaM");
+             "$6ckCB0tnVFMaOgvlGeW69ASzDOabPwGsO/ISKZYBCaM", Argon2_i);
     hashtest(version, 2, 16, 1, "password", "diffsalt",
              "79a103b90fe8aef8570cb31fc8b22259778916f8336b7bdac3892569d4f1c497",
              "$argon2i$m=65536,t=2,p=1$ZGlmZnNhbHQ"
-             "$eaEDuQ/orvhXDLMfyLIiWXeJFvgza3vaw4kladTxxJc");
+             "$eaEDuQ/orvhXDLMfyLIiWXeJFvgza3vaw4kladTxxJc", Argon2_i);
 
     /* Error state tests */
 
@@ -157,41 +156,42 @@ int main() {
     hashtest(version, 2, 16, 1, "password", "somesalt",
              "c1628832147d9720c5bd1cfd61367078729f6dfb6f8fea9ff98158e0d7816ed0",
              "$argon2i$v=19$m=65536,t=2,p=1$c29tZXNhbHQ"
-             "$wWKIMhR9lyDFvRz9YTZweHKfbftvj+qf+YFY4NeBbtA");
+             "$wWKIMhR9lyDFvRz9YTZweHKfbftvj+qf+YFY4NeBbtA", Argon2_i);
 #ifdef TEST_LARGE_RAM
     hashtest(version, 2, 20, 1, "password", "somesalt",
              "d1587aca0922c3b5d6a83edab31bee3c4ebaef342ed6127a55d19b2351ad1f41",
              "$argon2i$v=19$m=1048576,t=2,p=1$c29tZXNhbHQ"
-             "$0Vh6ygkiw7XWqD7asxvuPE667zQu1hJ6VdGbI1GtH0E");
+             "$0Vh6ygkiw7XWqD7asxvuPE667zQu1hJ6VdGbI1GtH0E", Argon2_i);
 #endif
     hashtest(version, 2, 18, 1, "password", "somesalt",
              "296dbae80b807cdceaad44ae741b506f14db0959267b183b118f9b24229bc7cb",
              "$argon2i$v=19$m=262144,t=2,p=1$c29tZXNhbHQ"
-             "$KW266AuAfNzqrUSudBtQbxTbCVkmexg7EY+bJCKbx8s");
+             "$KW266AuAfNzqrUSudBtQbxTbCVkmexg7EY+bJCKbx8s", Argon2_i);
     hashtest(version, 2, 8, 1, "password", "somesalt",
              "89e9029f4637b295beb027056a7336c414fadd43f6b208645281cb214a56452f",
              "$argon2i$v=19$m=256,t=2,p=1$c29tZXNhbHQ"
-             "$iekCn0Y3spW+sCcFanM2xBT63UP2sghkUoHLIUpWRS8");
+             "$iekCn0Y3spW+sCcFanM2xBT63UP2sghkUoHLIUpWRS8", Argon2_i);
     hashtest(version, 2, 8, 2, "password", "somesalt",
              "4ff5ce2769a1d7f4c8a491df09d41a9fbe90e5eb02155a13e4c01e20cd4eab61",
              "$argon2i$v=19$m=256,t=2,p=2$c29tZXNhbHQ"
-             "$T/XOJ2mh1/TIpJHfCdQan76Q5esCFVoT5MAeIM1Oq2E");
+             "$T/XOJ2mh1/TIpJHfCdQan76Q5esCFVoT5MAeIM1Oq2E", Argon2_i);
     hashtest(version, 1, 16, 1, "password", "somesalt",
              "d168075c4d985e13ebeae560cf8b94c3b5d8a16c51916b6f4ac2da3ac11bbecf",
              "$argon2i$v=19$m=65536,t=1,p=1$c29tZXNhbHQ"
-             "$0WgHXE2YXhPr6uVgz4uUw7XYoWxRkWtvSsLaOsEbvs8");
+             "$0WgHXE2YXhPr6uVgz4uUw7XYoWxRkWtvSsLaOsEbvs8", Argon2_i);
     hashtest(version, 4, 16, 1, "password", "somesalt",
              "aaa953d58af3706ce3df1aefd4a64a84e31d7f54175231f1285259f88174ce5b",
              "$argon2i$v=19$m=65536,t=4,p=1$c29tZXNhbHQ"
-             "$qqlT1YrzcGzj3xrv1KZKhOMdf1QXUjHxKFJZ+IF0zls");
+             "$qqlT1YrzcGzj3xrv1KZKhOMdf1QXUjHxKFJZ+IF0zls", Argon2_i);
     hashtest(version, 2, 16, 1, "differentpassword", "somesalt",
              "14ae8da01afea8700c2358dcef7c5358d9021282bd88663a4562f59fb74d22ee",
              "$argon2i$v=19$m=65536,t=2,p=1$c29tZXNhbHQ"
-             "$FK6NoBr+qHAMI1jc73xTWNkCEoK9iGY6RWL1n7dNIu4");
+             "$FK6NoBr+qHAMI1jc73xTWNkCEoK9iGY6RWL1n7dNIu4", Argon2_i);
     hashtest(version, 2, 16, 1, "password", "diffsalt",
              "b0357cccfbef91f3860b0dba447b2348cbefecadaf990abfe9cc40726c521271",
              "$argon2i$v=19$m=65536,t=2,p=1$ZGlmZnNhbHQ"
-             "$sDV8zPvvkfOGCw26RHsjSMvv7K2vmQq/6cxAcmxSEnE");
+             "$sDV8zPvvkfOGCw26RHsjSMvv7K2vmQq/6cxAcmxSEnE", Argon2_i);
+
 
     /* Error state tests */
 
@@ -225,7 +225,43 @@ int main() {
 
     msg = argon2_error_message(ARGON2_DECODING_FAIL);
     assert(strcmp(msg, "Decoding failed") == 0);
-    printf("Decode an error message: PASS\n");
+    printf("Decode an error message: PASS\n\n");
+
+    printf("Test Argon2id version number: %02x\n", version);
+
+    /* Multiple test cases for various input values */
+    hashtest(version, 2, 16, 1, "password", "somesalt",
+             "09316115d5cf24ed5a15a31a3ba326e5cf32edc24702987c02b6566f61913cf7",
+             "$argon2id$v=19$m=65536,t=2,p=1$c29tZXNhbHQ"
+             "$CTFhFdXPJO1aFaMaO6Mm5c8y7cJHAph8ArZWb2GRPPc", Argon2_id);
+    hashtest(version, 2, 18, 1, "password", "somesalt",
+             "78fe1ec91fb3aa5657d72e710854e4c3d9b9198c742f9616c2f085bed95b2e8c",
+             "$argon2id$v=19$m=262144,t=2,p=1$c29tZXNhbHQ"
+             "$eP4eyR+zqlZX1y5xCFTkw9m5GYx0L5YWwvCFvtlbLow", Argon2_id);
+    hashtest(version, 2, 8, 1, "password", "somesalt",
+             "9dfeb910e80bad0311fee20f9c0e2b12c17987b4cac90c2ef54d5b3021c68bfe",
+             "$argon2id$v=19$m=256,t=2,p=1$c29tZXNhbHQ"
+             "$nf65EOgLrQMR/uIPnA4rEsF5h7TKyQwu9U1bMCHGi/4", Argon2_id);
+    hashtest(version, 2, 8, 2, "password", "somesalt",
+             "6d093c501fd5999645e0ea3bf620d7b8be7fd2db59c20d9fff9539da2bf57037",
+             "$argon2id$v=19$m=256,t=2,p=2$c29tZXNhbHQ"
+             "$bQk8UB/VmZZF4Oo79iDXuL5/0ttZwg2f/5U52iv1cDc", Argon2_id);
+    hashtest(version, 1, 16, 1, "password", "somesalt",
+             "f6a5adc1ba723dddef9b5ac1d464e180fcd9dffc9d1cbf76cca2fed795d9ca98",
+             "$argon2id$v=19$m=65536,t=1,p=1$c29tZXNhbHQ"
+             "$9qWtwbpyPd3vm1rB1GThgPzZ3/ydHL92zKL+15XZypg", Argon2_id);
+    hashtest(version, 4, 16, 1, "password", "somesalt",
+             "9025d48e68ef7395cca9079da4c4ec3affb3c8911fe4f86d1a2520856f63172c",
+             "$argon2id$v=19$m=65536,t=4,p=1$c29tZXNhbHQ"
+             "$kCXUjmjvc5XMqQedpMTsOv+zyJEf5PhtGiUghW9jFyw", Argon2_id);
+    hashtest(version, 2, 16, 1, "differentpassword", "somesalt",
+             "0b84d652cf6b0c4beaef0dfe278ba6a80df6696281d7e0d2891b817d8c458fde",
+             "$argon2id$v=19$m=65536,t=2,p=1$c29tZXNhbHQ"
+             "$C4TWUs9rDEvq7w3+J4umqA32aWKB1+DSiRuBfYxFj94", Argon2_id);
+    hashtest(version, 2, 16, 1, "password", "diffsalt",
+             "bdf32b05ccc42eb15d58fd19b1f856b113da1e9a5874fdcc544308565aa8141c",
+             "$argon2id$v=19$m=65536,t=2,p=1$ZGlmZnNhbHQ"
+             "$vfMrBczELrFdWP0ZsfhWsRPaHppYdP3MVEMIVlqoFBw", Argon2_id);
 
     /* Common error state tests */
 
@@ -234,18 +270,18 @@ int main() {
 
     ret = argon2_hash(2, 1, 1, "password", strlen("password"),
                       "diffsalt", strlen("diffsalt"),
-                      out, OUT_LEN, NULL, 0, Argon2_i, version);
+                      out, OUT_LEN, NULL, 0, Argon2_id, version);
     assert(ret == ARGON2_MEMORY_TOO_LITTLE);
     printf("Fail on invalid memory: PASS\n");
 
     ret = argon2_hash(2, 1 << 12, 1, NULL, strlen("password"),
                       "diffsalt", strlen("diffsalt"),
-                      out, OUT_LEN, NULL, 0, Argon2_i, version);
+                      out, OUT_LEN, NULL, 0, Argon2_id, version);
     assert(ret == ARGON2_PWD_PTR_MISMATCH);
     printf("Fail on invalid null pointer: PASS\n");
 
     ret = argon2_hash(2, 1 << 12, 1, "password", strlen("password"), "s", 1,
-                      out, OUT_LEN, NULL, 0, Argon2_i, version);
+                      out, OUT_LEN, NULL, 0, Argon2_id, version);
     assert(ret == ARGON2_SALT_TOO_SHORT);
     printf("Fail on salt too short: PASS\n");
 

data/lib/argon2.rb

@@ -33,10 +33,11 @@ module Argon2
     end
 
     def self.verify_password(pass, hash, secret = nil)
+      # Supports argon2i and argon2id formats.
       raise ArgonHashFail, "Invalid hash" unless
-        /^\$argon2i\$.{,112}/ =~ hash
+        /^\$argon2i.{,113}/ =~ hash
 
-      Argon2::Engine.argon2i_verify(pass, hash, secret)
+      Argon2::Engine.argon2_verify(pass, hash, secret)
     end
   end
 end

data/lib/argon2/ffi_engine.rb

@@ -62,7 +62,7 @@ module Argon2
       result.delete "\0"
     end
 
-    def self.argon2i_verify(pwd, hash, secret)
+    def self.argon2_verify(pwd, hash, secret)
       secretlen = secret.nil? ? 0 : secret.bytesize
       passwordlen = pwd.nil? ? 0 : pwd.bytesize
 

data/lib/argon2/version.rb

@@ -3,5 +3,5 @@
 # Standard Gem version constant.
 
 module Argon2
-  VERSION = "1.1.5".freeze
+  VERSION = "1.2.0".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: argon2
 version: !ruby/object:Gem::Version
-  version: 1.1.5
+  version: 1.2.0
 platform: ruby
 authors:
 - Technion
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-04-30 00:00:00.000000000 Z
+date: 2018-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -252,7 +252,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Argon2 Password hashing binding