argon2 2.3.0 → 2.3.1

data/ext/phc-winner-argon2/libargon2.pc.in

@@ -1,18 +0,0 @@
-# libargon2 info for pkg-config
-## Template for downstream installers:
-## - replace @UPSTREAM_VER@ with current version, e.g. '20160406'
-## - replace @HOST_MULTIARCH@ with target arch lib, e.g. 'lib', 'lib/x86_64-linux-gnu' or 'lib64'
-## - replace @PREFIX@ with install path, e.g. '/usr', '/usr/local', '/usr/pkg'
-## - replace @INCLUDE@ with incluse path, e.g. 'include' or 'include/argon2'
-
-prefix=@PREFIX@
-exec_prefix=${prefix}
-libdir=${prefix}/@HOST_MULTIARCH@
-includedir=${prefix}/@INCLUDE@
-
-Name: libargon2
-Description: Development libraries for libargon2
-Version: @UPSTREAM_VER@
-Libs: -L${libdir} -largon2 @EXTRA_LIBS@
-Cflags: -I${includedir}
-URL: https://github.com/P-H-C/phc-winner-argon2

data/ext/phc-winner-argon2/man/argon2.1

@@ -1,57 +0,0 @@
-.TH ARGON2 "1" "April 2016" "argon2 " "User Commands"
-
-.SH NAME
-argon2 \- generate argon2 hashes
-
-.SH SYNOPSIS
-.B argon2 salt
-.RB [ OPTIONS ]
-
-.SH DESCRIPTION
-Generate Argon2 hashes from the command line.
-
-The supplied salt (the first argument to the command) must be at least
-8 octets in length, and the password is supplied on standard input.
-
-By default, this uses Argon2i variant (where memory access is
-independent of secret data) which is the preferred one for password
-hashing and password-based key derivation.
-
-.SH OPTIONS
-.TP
-.B \-h
-Display tool usage
-.TP
-.B \-d
-Use Argon2d instead of Argon2i (Argon2i is the default)
-.TP
-.B \-id
-Use Argon2id instead of Argon2i (Argon2i is the default)
-.TP
-.BI \-t " N"
-Sets the number of iterations to N (default = 3)
-.TP
-.BI \-m " N"
-Sets the memory usage of 2^N KiB (default = 12)
-.TP
-.BI \-p " N"
-Sets parallelism to N threads (default = 1)
-.TP
-.BI \-l " N"
-Sets hash output length to N bytes (default = 32)
-.TP
-.B \-e
-Output only encoded hash
-.TP
-.B \-r
-Output only the raw bytes of the hash
-.TP
-.B \-v (10|13)
-Argon2 version (defaults to the most recent version, currently 13)
-
-.SH COPYRIGHT
-This manpage was written by \fBDaniel Kahn Gillmor\fR for the Debian
-distribution (but may be used by others).  It is released, like the
-rest of this Argon2 implementation, under a dual license. You may use this work
-under the terms of a Creative Commons CC0 1.0 License/Waiver or the Apache
-Public License 2.0, at your option.

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

@@ -1,452 +0,0 @@
-/*
- * Argon2 reference source code package - reference C implementations
- *
- * Copyright 2015
- * Daniel Dinu, Dmitry Khovratovich, Jean-Philippe Aumasson, and Samuel Neves
- *
- * You may use this work under the terms of a Creative Commons CC0 1.0
- * License/Waiver or the Apache Public License 2.0, at your option. The terms of
- * these licenses can be found at:
- *
- * - CC0 1.0 Universal : https://creativecommons.org/publicdomain/zero/1.0
- * - Apache 2.0        : https://www.apache.org/licenses/LICENSE-2.0
- *
- * You should have received a copy of both of these licenses along with this
- * software. If not, they may be obtained at the above URLs.
- */
-
-#include <string.h>
-#include <stdlib.h>
-#include <stdio.h>
-
-#include "argon2.h"
-#include "encoding.h"
-#include "core.h"
-
-const char *argon2_type2string(argon2_type type, int uppercase) {
-    switch (type) {
-        case Argon2_d:
-            return uppercase ? "Argon2d" : "argon2d";
-        case Argon2_i:
-            return uppercase ? "Argon2i" : "argon2i";
-        case Argon2_id:
-            return uppercase ? "Argon2id" : "argon2id";
-    }
-
-    return NULL;
-}
-
-int argon2_ctx(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 && Argon2_id != 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.version = context->version;
-    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;
-
-    if (instance.threads > instance.lanes) {
-        instance.threads = instance.lanes;
-    }
-
-    /* 3. Initialization: Hashing inputs, allocating memory, filling first
-     * blocks
-     */
-    result = initialize(&instance, context);
-
-    if (ARGON2_OK != result) {
-        return result;
-    }
-
-    /* 4. Filling memory */
-    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,
-                void *hash, const size_t hashlen, char *encoded,
-                const size_t encodedlen, argon2_type type,
-                const uint32_t version){
-
-    argon2_context context;
-    int result;
-    uint8_t *out;
-
-    if (pwdlen > ARGON2_MAX_PWD_LENGTH) {
-        return ARGON2_PWD_TOO_LONG;
-    }
-
-    if (saltlen > ARGON2_MAX_SALT_LENGTH) {
-        return ARGON2_SALT_TOO_LONG;
-    }
-
-    if (hashlen > ARGON2_MAX_OUTLEN) {
-        return ARGON2_OUTPUT_TOO_LONG;
-    }
-
-    if (hashlen < ARGON2_MIN_OUTLEN) {
-        return ARGON2_OUTPUT_TOO_SHORT;
-    }
-
-    out = malloc(hashlen);
-    if (!out) {
-        return ARGON2_MEMORY_ALLOCATION_ERROR;
-    }
-
-    context.out = (uint8_t *)out;
-    context.outlen = (uint32_t)hashlen;
-    context.pwd = CONST_CAST(uint8_t *)pwd;
-    context.pwdlen = (uint32_t)pwdlen;
-    context.salt = CONST_CAST(uint8_t *)salt;
-    context.saltlen = (uint32_t)saltlen;
-    context.secret = NULL;
-    context.secretlen = 0;
-    context.ad = NULL;
-    context.adlen = 0;
-    context.t_cost = t_cost;
-    context.m_cost = m_cost;
-    context.lanes = parallelism;
-    context.threads = parallelism;
-    context.allocate_cbk = NULL;
-    context.free_cbk = NULL;
-    context.flags = ARGON2_DEFAULT_FLAGS;
-    context.version = version;
-
-    result = argon2_ctx(&context, type);
-
-    if (result != ARGON2_OK) {
-        clear_internal_memory(out, hashlen);
-        free(out);
-        return result;
-    }
-
-    /* if raw hash requested, write it */
-    if (hash) {
-        memcpy(hash, out, hashlen);
-    }
-
-    /* if encoding requested, write it */
-    if (encoded && encodedlen) {
-        if (encode_string(encoded, encodedlen, &context, type) != ARGON2_OK) {
-            clear_internal_memory(out, hashlen); /* wipe buffers if error */
-            clear_internal_memory(encoded, encodedlen);
-            free(out);
-            return ARGON2_ENCODING_FAIL;
-        }
-    }
-    clear_internal_memory(out, hashlen);
-    free(out);
-
-    return ARGON2_OK;
-}
-
-int argon2i_hash_encoded(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, const size_t hashlen,
-                         char *encoded, const size_t encodedlen) {
-
-    return argon2_hash(t_cost, m_cost, parallelism, pwd, pwdlen, salt, saltlen,
-                       NULL, hashlen, encoded, encodedlen, Argon2_i,
-                       ARGON2_VERSION_NUMBER);
-}
-
-int argon2i_hash_raw(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, void *hash, const size_t hashlen) {
-
-    return argon2_hash(t_cost, m_cost, parallelism, pwd, pwdlen, salt, saltlen,
-                       hash, hashlen, NULL, 0, Argon2_i, ARGON2_VERSION_NUMBER);
-}
-
-int argon2d_hash_encoded(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, const size_t hashlen,
-                         char *encoded, const size_t encodedlen) {
-
-    return argon2_hash(t_cost, m_cost, parallelism, pwd, pwdlen, salt, saltlen,
-                       NULL, hashlen, encoded, encodedlen, Argon2_d,
-                       ARGON2_VERSION_NUMBER);
-}
-
-int argon2d_hash_raw(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, void *hash, const size_t hashlen) {
-
-    return argon2_hash(t_cost, m_cost, parallelism, pwd, pwdlen, salt, saltlen,
-                       hash, hashlen, NULL, 0, Argon2_d, ARGON2_VERSION_NUMBER);
-}
-
-int argon2id_hash_encoded(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, const size_t hashlen,
-                          char *encoded, const size_t encodedlen) {
-
-    return argon2_hash(t_cost, m_cost, parallelism, pwd, pwdlen, salt, saltlen,
-                       NULL, hashlen, encoded, encodedlen, Argon2_id,
-                       ARGON2_VERSION_NUMBER);
-}
-
-int argon2id_hash_raw(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, void *hash, const size_t hashlen) {
-    return argon2_hash(t_cost, m_cost, parallelism, pwd, pwdlen, salt, saltlen,
-                       hash, hashlen, NULL, 0, Argon2_id,
-                       ARGON2_VERSION_NUMBER);
-}
-
-static int argon2_compare(const uint8_t *b1, const uint8_t *b2, size_t len) {
-    size_t i;
-    uint8_t d = 0U;
-
-    for (i = 0U; i < len; i++) {
-        d |= b1[i] ^ b2[i];
-    }
-    return (int)((1 & ((d - 1) >> 8)) - 1);
-}
-
-int argon2_verify(const char *encoded, const void *pwd, const size_t pwdlen,
-                  argon2_type type) {
-
-    argon2_context ctx;
-    uint8_t *desired_result = NULL;
-
-    int ret = ARGON2_OK;
-
-    size_t encoded_len;
-    uint32_t max_field_len;
-
-    if (pwdlen > ARGON2_MAX_PWD_LENGTH) {
-        return ARGON2_PWD_TOO_LONG;
-    }
-
-    if (encoded == NULL) {
-        return ARGON2_DECODING_FAIL;
-    }
-
-    encoded_len = strlen(encoded);
-    if (encoded_len > UINT32_MAX) {
-        return ARGON2_DECODING_FAIL;
-    }
-
-    /* No field can be longer than the encoded length */
-    max_field_len = (uint32_t)encoded_len;
-
-    ctx.saltlen = max_field_len;
-    ctx.outlen = max_field_len;
-
-    ctx.salt = malloc(ctx.saltlen);
-    ctx.out = malloc(ctx.outlen);
-    if (!ctx.salt || !ctx.out) {
-        ret = ARGON2_MEMORY_ALLOCATION_ERROR;
-        goto fail;
-    }
-
-    ctx.pwd = (uint8_t *)pwd;
-    ctx.pwdlen = (uint32_t)pwdlen;
-
-    ret = decode_string(&ctx, encoded, type);
-    if (ret != ARGON2_OK) {
-        goto fail;
-    }
-
-    /* Set aside the desired result, and get a new buffer. */
-    desired_result = ctx.out;
-    ctx.out = malloc(ctx.outlen);
-    if (!ctx.out) {
-        ret = ARGON2_MEMORY_ALLOCATION_ERROR;
-        goto fail;
-    }
-
-    ret = argon2_verify_ctx(&ctx, (char *)desired_result, type);
-    if (ret != ARGON2_OK) {
-        goto fail;
-    }
-
-fail:
-    free(ctx.salt);
-    free(ctx.out);
-    free(desired_result);
-
-    return ret;
-}
-
-int argon2i_verify(const char *encoded, const void *pwd, const size_t pwdlen) {
-
-    return argon2_verify(encoded, pwd, pwdlen, Argon2_i);
-}
-
-int argon2d_verify(const char *encoded, const void *pwd, const size_t pwdlen) {
-
-    return argon2_verify(encoded, pwd, pwdlen, Argon2_d);
-}
-
-int argon2id_verify(const char *encoded, const void *pwd, const size_t pwdlen) {
-
-    return argon2_verify(encoded, pwd, pwdlen, Argon2_id);
-}
-
-int argon2d_ctx(argon2_context *context) {
-    return argon2_ctx(context, Argon2_d);
-}
-
-int argon2i_ctx(argon2_context *context) {
-    return argon2_ctx(context, Argon2_i);
-}
-
-int argon2id_ctx(argon2_context *context) {
-    return argon2_ctx(context, Argon2_id);
-}
-
-int argon2_verify_ctx(argon2_context *context, const char *hash,
-                      argon2_type type) {
-    int ret = argon2_ctx(context, type);
-    if (ret != ARGON2_OK) {
-        return ret;
-    }
-
-    if (argon2_compare((uint8_t *)hash, context->out, context->outlen)) {
-        return ARGON2_VERIFY_MISMATCH;
-    }
-
-    return ARGON2_OK;
-}
-
-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);
-}
-
-int argon2id_verify_ctx(argon2_context *context, const char *hash) {
-    return argon2_verify_ctx(context, hash, Argon2_id);
-}
-
-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";
-    }
-}
-
-size_t argon2_encodedlen(uint32_t t_cost, uint32_t m_cost, uint32_t parallelism,
-                         uint32_t saltlen, uint32_t hashlen, argon2_type type) {
-  return strlen("$$v=$m=,t=,p=$$") + strlen(argon2_type2string(type, 0)) +
-         numlen(t_cost) + numlen(m_cost) + numlen(parallelism) +
-         b64len(saltlen) + b64len(hashlen) + numlen(ARGON2_VERSION_NUMBER) + 1;
-}

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

@@ -1,111 +0,0 @@
-/*
- * Argon2 reference source code package - reference C implementations
- *
- * Copyright 2015
- * Daniel Dinu, Dmitry Khovratovich, Jean-Philippe Aumasson, and Samuel Neves
- *
- * You may use this work under the terms of a Creative Commons CC0 1.0
- * License/Waiver or the Apache Public License 2.0, at your option. The terms of
- * these licenses can be found at:
- *
- * - CC0 1.0 Universal : https://creativecommons.org/publicdomain/zero/1.0
- * - Apache 2.0        : https://www.apache.org/licenses/LICENSE-2.0
- *
- * You should have received a copy of both of these licenses along with this
- * software. If not, they may be obtained at the above URLs.
- */
-
-#include <stdio.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-#ifdef _WIN32
-#include <intrin.h>
-#endif
-
-#include "argon2.h"
-
-static uint64_t rdtsc(void) {
-#ifdef _WIN32
-    return __rdtsc();
-#else
-#if defined(__amd64__) || defined(__x86_64__)
-    uint64_t rax, rdx;
-    __asm__ __volatile__("rdtsc" : "=a"(rax), "=d"(rdx) : :);
-    return (rdx << 32) | rax;
-#elif defined(__i386__) || defined(__i386) || defined(__X86__)
-    uint64_t rax;
-    __asm__ __volatile__("rdtsc" : "=A"(rax) : :);
-    return rax;
-#else
-#error "Not implemented!"
-#endif
-#endif
-}
-
-/*
- * Benchmarks Argon2 with salt length 16, password length 16, t_cost 3,
-   and different m_cost and threads
- */
-static void benchmark() {
-#define BENCH_OUTLEN 16
-#define BENCH_INLEN 16
-    const uint32_t inlen = BENCH_INLEN;
-    const unsigned outlen = BENCH_OUTLEN;
-    unsigned char out[BENCH_OUTLEN];
-    unsigned char pwd_array[BENCH_INLEN];
-    unsigned char salt_array[BENCH_INLEN];
-#undef BENCH_INLEN
-#undef BENCH_OUTLEN
-
-    uint32_t t_cost = 3;
-    uint32_t m_cost;
-    uint32_t thread_test[4] = {1, 2, 4,  8};
-    argon2_type types[3] = {Argon2_i, Argon2_d, Argon2_id};
-
-    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 < 4; ++i) {
-            double run_time = 0;
-            uint32_t thread_n = thread_test[i];
-
-            unsigned j;
-            for (j = 0; j < 3; ++j) {
-                clock_t start_time, stop_time;
-                uint64_t start_cycles, stop_cycles;
-                uint64_t delta;
-                double mcycles;
-
-                argon2_type type = types[j];
-                start_time = clock();
-                start_cycles = rdtsc();
-
-                argon2_hash(t_cost, m_cost, thread_n, pwd_array, inlen,
-                            salt_array, inlen, out, outlen, NULL, 0, type,
-                            ARGON2_VERSION_NUMBER);
-
-                stop_cycles = rdtsc();
-                stop_time = clock();
-
-                delta = (stop_cycles - start_cycles) / (m_cost);
-                mcycles = (double)(stop_cycles - start_cycles) / (1UL << 20);
-                run_time += ((double)stop_time - start_time) / (CLOCKS_PER_SEC);
-
-                printf("%s %d iterations  %d MiB %d threads:  %2.2f cpb %2.2f "
-                       "Mcycles \n", argon2_type2string(type, 1), t_cost,
-                       m_cost >> 10, thread_n, (float)delta / 1024, mcycles);
-            }
-
-            printf("%2.4f seconds\n\n", run_time);
-        }
-    }
-}
-
-int main() {
-    benchmark();
-    return ARGON2_OK;
-}