argon2 0.1.4 → 1.0.0

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

@@ -1 +1 @@
-82ca18d6df38a67b1a52f610f19f1917e5b118014fe31995c83350b92319fa06  argon2i
+0d703f555eb72b8b36b4f486333aa130a5ebe32f39a96bbc439def0db569115a  argon2i

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

@@ -11,102 +11,16 @@
  * <http://creativecommons.org/publicdomain/zero/1.0/>.
  */
 
-#include <stdint.h>
 #include <string.h>
 #include <stdlib.h>
 #include <stdio.h>
-#include <limits.h>
 
 #include "argon2.h"
 #include "encoding.h"
 #include "core.h"
 
-/* Error messages */
-static const char *Argon2_ErrorMessage[] = {
-    /*{ARGON2_OK, */ "OK",
-    /*},
-
-    {ARGON2_OUTPUT_PTR_NULL, */ "Output pointer is NULL",
-    /*},
-
-{ARGON2_OUTPUT_TOO_SHORT, */ "Output is too short",
-    /*},
-{ARGON2_OUTPUT_TOO_LONG, */ "Output is too long",
-    /*},
-
-{ARGON2_PWD_TOO_SHORT, */ "Password is too short",
-    /*},
-{ARGON2_PWD_TOO_LONG, */ "Password is too long",
-    /*},
-
-{ARGON2_SALT_TOO_SHORT, */ "Salt is too short",
-    /*},
-{ARGON2_SALT_TOO_LONG, */ "Salt is too long",
-    /*},
-
-{ARGON2_AD_TOO_SHORT, */ "Associated data is too short",
-    /*},
-{ARGON2_AD_TOO_LONG, */ "Associated date is too long",
-    /*},
-
-{ARGON2_SECRET_TOO_SHORT, */ "Secret is too short",
-    /*},
-{ARGON2_SECRET_TOO_LONG, */ "Secret is too long",
-    /*},
-
-{ARGON2_TIME_TOO_SMALL, */ "Time cost is too small",
-    /*},
-{ARGON2_TIME_TOO_LARGE, */ "Time cost is too large",
-    /*},
-
-{ARGON2_MEMORY_TOO_LITTLE, */ "Memory cost is too small",
-    /*},
-{ARGON2_MEMORY_TOO_MUCH, */ "Memory cost is too large",
-    /*},
-
-{ARGON2_LANES_TOO_FEW, */ "Too few lanes",
-    /*},
-{ARGON2_LANES_TOO_MANY, */ "Too many lanes",
-    /*},
-
-{ARGON2_PWD_PTR_MISMATCH, */ "Password pointer is NULL, but password length is not 0",
-    /*},
-{ARGON2_SALT_PTR_MISMATCH, */ "Salt pointer is NULL, but salt length is not 0",
-    /*},
-{ARGON2_SECRET_PTR_MISMATCH, */ "Secret pointer is NULL, but secret length is not 0",
-    /*},
-{ARGON2_AD_PTR_MISMATCH, */ "Associated data pointer is NULL, but ad length is not 0",
-    /*},
-
-{ARGON2_MEMORY_ALLOCATION_ERROR, */ "Memory allocation error",
-    /*},
-
-{ARGON2_FREE_MEMORY_CBK_NULL, */ "The free memory callback is NULL",
-    /*},
-{ARGON2_ALLOCATE_MEMORY_CBK_NULL, */ "The allocate memory callback is NULL",
-    /*},
-
-{ARGON2_INCORRECT_PARAMETER, */ "Argon2_Context context is NULL",
-    /*},
-{ARGON2_INCORRECT_TYPE, */ "There is no such version of Argon2",
-    /*},
-
-{ARGON2_OUT_PTR_MISMATCH, */ "Output pointer mismatch",
-    /*},
-
-{ARGON2_THREADS_TOO_FEW, */ "Not enough threads",
-    /*},
-{ARGON2_THREADS_TOO_MANY, */ "Too many threads",
-    /*},
-{ARGON2_MISSING_ARGS, */ "Missing arguments",
-    /*},
-{ARGON2_ENCODING_FAIL, */ "Encoding failed",
-    /*},
-{ARGON2_DECODING_FAIL, */ "Decoding failed", /*},*/
-};
-
-
-int argon2_core(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;
@@ -151,15 +65,17 @@ int argon2_core(argon2_context *context, argon2_type type) {
     }
 
     /* 4. Filling memory */
-    fill_memory_blocks(&instance);
+    result = fill_memory_blocks(&instance);
 
+    if (ARGON2_OK != result) {
+        return result;
+    }
     /* 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,
@@ -172,15 +88,15 @@ int argon2_hash(const uint32_t t_cost, const uint32_t m_cost,
 
     /* Detect and reject overflowing sizes */
     /* TODO: This should probably be fixed in the function signature */
-    if (pwdlen > UINT32_MAX) {
+    if (pwdlen > ARGON2_MAX_PWD_LENGTH) {
         return ARGON2_PWD_TOO_LONG;
     }
 
-    if (hashlen > UINT32_MAX) {
+    if (hashlen > ARGON2_MAX_OUTLEN) {
         return ARGON2_OUTPUT_TOO_LONG;
     }
 
-    if (saltlen > UINT32_MAX) {
+    if (saltlen > ARGON2_MAX_SALT_LENGTH) {
         return ARGON2_SALT_TOO_LONG;
     }
 
@@ -191,9 +107,9 @@ int argon2_hash(const uint32_t t_cost, const uint32_t m_cost,
 
     context.out = (uint8_t *)out;
     context.outlen = (uint32_t)hashlen;
-    context.pwd = (uint8_t *)pwd;
+    context.pwd = CONST_CAST(uint8_t *)pwd;
     context.pwdlen = (uint32_t)pwdlen;
-    context.salt = (uint8_t *)salt;
+    context.salt = CONST_CAST(uint8_t *)salt;
     context.saltlen = (uint32_t)saltlen;
     context.secret = NULL;
     context.secretlen = 0;
@@ -207,10 +123,10 @@ int argon2_hash(const uint32_t t_cost, const uint32_t m_cost,
     context.free_cbk = NULL;
     context.flags = ARGON2_DEFAULT_FLAGS;
 
-    result = argon2_core(&context, type);
+    result = argon2_ctx(&context, type);
 
     if (result != ARGON2_OK) {
-        memset(out, 0x00, hashlen);
+        secure_wipe_memory(out, hashlen);
         free(out);
         return result;
     }
@@ -222,14 +138,14 @@ int argon2_hash(const uint32_t t_cost, const uint32_t m_cost,
 
     /* if encoding requested, write it */
     if (encoded && encodedlen) {
-        if (!encode_string(encoded, encodedlen, &context, type)) {
-            memset(out, 0x00, hashlen);
-            memset(encoded, 0x00, encodedlen);
+        if (encode_string(encoded, encodedlen, &context, type) != ARGON2_OK) {
+            secure_wipe_memory(out, hashlen); /* wipe buffers if error */
+            secure_wipe_memory(encoded, encodedlen);
             free(out);
             return ARGON2_ENCODING_FAIL;
         }
     }
-
+    secure_wipe_memory(out, hashlen);
     free(out);
 
     return ARGON2_OK;
@@ -273,7 +189,7 @@ int argon2d_hash_raw(const uint32_t t_cost, const uint32_t m_cost,
                        hash, hashlen, NULL, 0, Argon2_d);
 }
 
-int argon2_compare(const uint8_t *b1, const uint8_t *b2, size_t len) {
+static int argon2_compare(const uint8_t *b1, const uint8_t *b2, size_t len) {
     size_t i;
     uint8_t d = 0U;
 
@@ -289,12 +205,17 @@ int argon2_verify(const char *encoded, const void *pwd, const size_t pwdlen,
     argon2_context ctx;
     uint8_t *out;
     int ret;
+    int decode_result;
 
     /* max values, to be updated in decode_string */
-    ctx.adlen = 512;
-    ctx.saltlen = 512;
-    ctx.outlen = 512;
-
+    uint32_t encoded_len = strlen(encoded);
+    ctx.adlen = encoded_len;
+    ctx.saltlen = encoded_len;
+    ctx.outlen = encoded_len;
+    ctx.allocate_cbk = NULL;
+    ctx.free_cbk = NULL;
+    ctx.secret = NULL;
+    ctx.secretlen = 0;
     ctx.ad = malloc(ctx.adlen);
     ctx.salt = malloc(ctx.saltlen);
     ctx.out = malloc(ctx.outlen);
@@ -311,30 +232,28 @@ int argon2_verify(const char *encoded, const void *pwd, const size_t pwdlen,
         free(ctx.out);
         return ARGON2_MEMORY_ALLOCATION_ERROR;
     }
-
-    if(decode_string(&ctx, encoded, type) != 1) {
+    decode_result = decode_string(&ctx, encoded, type);
+    if (decode_result != ARGON2_OK) {
         free(ctx.ad);
         free(ctx.salt);
         free(ctx.out);
         free(out);
-        return ARGON2_DECODING_FAIL;
+        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);
 
-    if (ret != ARGON2_OK || argon2_compare(out, ctx.out, ctx.outlen)) {
-        free(out);
-        free(ctx.out);
-        return ARGON2_DECODING_FAIL;
+    if (ret == ARGON2_OK && argon2_compare(out, ctx.out, ctx.outlen)) {
+        ret = ARGON2_VERIFY_MISMATCH;
     }
     free(out);
     free(ctx.out);
 
-    return ARGON2_OK;
+    return ret;
 }
 
 int argon2i_verify(const char *encoded, const void *pwd, const size_t pwdlen) {
@@ -347,17 +266,22 @@ int argon2d_verify(const char *encoded, const void *pwd, const size_t pwdlen) {
     return argon2_verify(encoded, pwd, pwdlen, Argon2_d);
 }
 
-int argon2d(argon2_context *context) { return argon2_core(context, Argon2_d); }
+int argon2d_ctx(argon2_context *context) {
+    return argon2_ctx(context, Argon2_d);
+}
 
-int argon2i(argon2_context *context) { return argon2_core(context, Argon2_i); }
+int argon2i_ctx(argon2_context *context) {
+    return argon2_ctx(context, Argon2_i);
+}
 
-int verify_d(argon2_context *context, const char *hash) {
+int argon2_verify_ctx(argon2_context *context, const char *hash,
+                      argon2_type type) {
     int result;
     if (0 == context->outlen || NULL == hash) {
         return ARGON2_OUT_PTR_MISMATCH;
     }
 
-    result = argon2_core(context, Argon2_d);
+    result = argon2_ctx(context, type);
 
     if (ARGON2_OK != result) {
         return result;
@@ -366,33 +290,89 @@ 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);
+int argon2d_verify_ctx(argon2_context *context, const char *hash) {
+    return argon2_verify_ctx(context, hash, Argon2_d);
 }
 
+int argon2i_verify_ctx(argon2_context *context, const char *hash) {
+    return argon2_verify_ctx(context, hash, Argon2_i);
+}
 
-const char *error_message(int error_code) {
-    enum {
-        /* Make sure---at compile time---that the enum size matches the array
-           size */
-        ERROR_STRING_CHECK =
-            1 /
-            !!((sizeof(Argon2_ErrorMessage) / sizeof(Argon2_ErrorMessage[0])) ==
-               ARGON2_ERROR_CODES_LENGTH)
-    };
-    if (error_code < ARGON2_ERROR_CODES_LENGTH) {
-        return Argon2_ErrorMessage[(argon2_error_codes)error_code];
+const char *argon2_error_message(int error_code) {
+    switch (error_code) {
+    case ARGON2_OK:
+        return "OK";
+    case ARGON2_OUTPUT_PTR_NULL:
+        return "Output pointer is NULL";
+    case ARGON2_OUTPUT_TOO_SHORT:
+        return "Output is too short";
+    case ARGON2_OUTPUT_TOO_LONG:
+        return "Output is too long";
+    case ARGON2_PWD_TOO_SHORT:
+        return "Password is too short";
+    case ARGON2_PWD_TOO_LONG:
+        return "Password is too long";
+    case ARGON2_SALT_TOO_SHORT:
+        return "Salt is too short";
+    case ARGON2_SALT_TOO_LONG:
+        return "Salt is too long";
+    case ARGON2_AD_TOO_SHORT:
+        return "Associated data is too short";
+    case ARGON2_AD_TOO_LONG:
+        return "Associated data is too long";
+    case ARGON2_SECRET_TOO_SHORT:
+        return "Secret is too short";
+    case ARGON2_SECRET_TOO_LONG:
+        return "Secret is too long";
+    case ARGON2_TIME_TOO_SMALL:
+        return "Time cost is too small";
+    case ARGON2_TIME_TOO_LARGE:
+        return "Time cost is too large";
+    case ARGON2_MEMORY_TOO_LITTLE:
+        return "Memory cost is too small";
+    case ARGON2_MEMORY_TOO_MUCH:
+        return "Memory cost is too large";
+    case ARGON2_LANES_TOO_FEW:
+        return "Too few lanes";
+    case ARGON2_LANES_TOO_MANY:
+        return "Too many lanes";
+    case ARGON2_PWD_PTR_MISMATCH:
+        return "Password pointer is NULL, but password length is not 0";
+    case ARGON2_SALT_PTR_MISMATCH:
+        return "Salt pointer is NULL, but salt length is not 0";
+    case ARGON2_SECRET_PTR_MISMATCH:
+        return "Secret pointer is NULL, but secret length is not 0";
+    case ARGON2_AD_PTR_MISMATCH:
+        return "Associated data pointer is NULL, but ad length is not 0";
+    case ARGON2_MEMORY_ALLOCATION_ERROR:
+        return "Memory allocation error";
+    case ARGON2_FREE_MEMORY_CBK_NULL:
+        return "The free memory callback is NULL";
+    case ARGON2_ALLOCATE_MEMORY_CBK_NULL:
+        return "The allocate memory callback is NULL";
+    case ARGON2_INCORRECT_PARAMETER:
+        return "Argon2_Context context is NULL";
+    case ARGON2_INCORRECT_TYPE:
+        return "There is no such version of Argon2";
+    case ARGON2_OUT_PTR_MISMATCH:
+        return "Output pointer mismatch";
+    case ARGON2_THREADS_TOO_FEW:
+        return "Not enough threads";
+    case ARGON2_THREADS_TOO_MANY:
+        return "Too many threads";
+    case ARGON2_MISSING_ARGS:
+        return "Missing arguments";
+    case ARGON2_ENCODING_FAIL:
+        return "Encoding failed";
+    case ARGON2_DECODING_FAIL:
+        return "Decoding failed";
+    case ARGON2_THREAD_FAIL:
+        return "Threading failure";
+    case ARGON2_DECODING_LENGTH_FAIL:
+        return "Some of encoded parameters are too long or too short";
+    case ARGON2_VERIFY_MISMATCH:
+        return "The password does not match the supplied hash";
+    default:
+        return "Unknown error code";
     }
-    return "Unknown error code.";
 }

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

@@ -42,16 +42,16 @@ static void benchmark() {
 #undef BENCH_INLEN
 #undef BENCH_OUTLEN
 
-    uint32_t t_cost = 1;
+    uint32_t t_cost = 3;
     uint32_t m_cost;
-    uint32_t thread_test[6] = {1, 2, 4, 6, 8, 16};
+    uint32_t thread_test[4] = {1, 2, 4,  8};
 
     memset(pwd_array, 0, inlen);
     memset(salt_array, 1, inlen);
 
     for (m_cost = (uint32_t)1 << 10; m_cost <= (uint32_t)1 << 22; m_cost *= 2) {
         unsigned i;
-        for (i = 0; i < 6; ++i) {
+        for (i = 0; i < 4; ++i) {
             argon2_context context;
             uint32_t thread_n = thread_test[i];
             uint64_t stop_cycles, stop_cycles_i;
@@ -80,9 +80,9 @@ static void benchmark() {
             context.free_cbk = NULL;
             context.flags = 0;
 
-            argon2d(&context);
+            argon2d_ctx(&context);
             stop_cycles = rdtsc();
-            argon2i(&context);
+            argon2i_ctx(&context);
             stop_cycles_i = rdtsc();
             stop_time = clock();
 

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

@@ -88,12 +88,11 @@ int allocate_memory(block **memory, uint32_t m_cost) {
             return ARGON2_MEMORY_ALLOCATION_ERROR;
         }
 
-        *memory = (block *)malloc(memory_size); /*2. Try to allocate*/
+        *memory = (block *)calloc(memory_size, 1); /*2. Try to allocate*/
 
         if (!*memory) {
             return ARGON2_MEMORY_ALLOCATION_ERROR;
         }
-
         return ARGON2_OK;
     } else {
         return ARGON2_MEMORY_ALLOCATION_ERROR;
@@ -249,25 +248,25 @@ static void *fill_segment_thr(void *thread_data)
     return 0;
 }
 
-void fill_memory_blocks(argon2_instance_t *instance) {
+int fill_memory_blocks(argon2_instance_t *instance) {
     uint32_t r, s;
     argon2_thread_handle_t *thread = NULL;
     argon2_thread_data *thr_data = NULL;
 
     if (instance == NULL || instance->lanes == 0) {
-        return;
+        return ARGON2_THREAD_FAIL;
     }
 
     /* 1. Allocating space for threads */
     thread = calloc(instance->lanes, sizeof(argon2_thread_handle_t));
     if (thread == NULL) {
-        return;
+        return ARGON2_MEMORY_ALLOCATION_ERROR;
     }
 
     thr_data = calloc(instance->lanes, sizeof(argon2_thread_data));
     if (thr_data == NULL) {
         free(thread);
-        return;
+        return ARGON2_MEMORY_ALLOCATION_ERROR;
     }
 
     for (r = 0; r < instance->passes; ++r) {
@@ -283,10 +282,9 @@ void fill_memory_blocks(argon2_instance_t *instance) {
                 if (l >= instance->threads) {
                     rc = argon2_thread_join(thread[l - instance->threads]);
                     if (rc) {
-                        printf(
-                            "ERROR; return code from pthread_join() #1 is %d\n",
-                            rc);
-                        exit(-1);
+                        free(thr_data);
+                        free(thread);
+                        return ARGON2_THREAD_FAIL;
                     }
                 }
 
@@ -302,13 +300,12 @@ void fill_memory_blocks(argon2_instance_t *instance) {
                 rc = argon2_thread_create(&thread[l], &fill_segment_thr,
                                           (void *)&thr_data[l]);
                 if (rc) {
-                    printf("ERROR; return code from argon2_thread_create() is "
-                           "%d\n",
-                           rc);
-                    exit(-1);
+                    free(thr_data);
+                    free(thread);
+                    return ARGON2_THREAD_FAIL;
                 }
 
-                /* FillSegment(instance, position); */
+                /* fill_segment(instance, position); */
                 /*Non-thread equivalent of the lines above */
             }
 
@@ -317,9 +314,7 @@ void fill_memory_blocks(argon2_instance_t *instance) {
                  ++l) {
                 rc = argon2_thread_join(thread[l]);
                 if (rc) {
-                    printf("ERROR; return code from pthread_join() is %d\n",
-                           rc);
-                    exit(-1);
+                    return ARGON2_THREAD_FAIL;
                 }
             }
         }
@@ -335,6 +330,7 @@ void fill_memory_blocks(argon2_instance_t *instance) {
     if (thr_data != NULL) {
         free(thr_data);
     }
+    return ARGON2_OK;
 }
 
 int validate_inputs(const argon2_context *context) {
@@ -424,7 +420,7 @@ int validate_inputs(const argon2_context *context) {
         return ARGON2_MEMORY_TOO_MUCH;
     }
 
-    if (context->m_cost < 8*context->lanes) {
+    if (context->m_cost < 8 * context->lanes) {
         return ARGON2_MEMORY_TOO_LITTLE;
     }
 
@@ -609,4 +605,3 @@ int initialize(argon2_instance_t *instance, argon2_context *context) {
 
     return ARGON2_OK;
 }
-