Herbert Poul
5 years ago
23 changed files with 4216 additions and 60 deletions
@ -0,0 +1,3 @@
|
||||
these files are copies from ../ios/Classes/ |
||||
they should stay in sync. |
||||
|
||||
@ -0,0 +1,136 @@
|
||||
#include <stdint.h> |
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
#include <stdio.h> |
||||
#include "argon2src/argon2.h" |
||||
|
||||
//extern "C" __attribute__((visibility("default"))) __attribute__((used))
|
||||
int32_t native_add(int32_t x, int32_t y) { |
||||
return x + y; |
||||
} |
||||
//EOF
|
||||
|
||||
#define HASHLEN 32 |
||||
#define SALTLEN 16 |
||||
#define PWD "password" |
||||
|
||||
#define DEBUG 0 |
||||
#define PRINT_DEBUG(fmt, ...) \ |
||||
do { if (DEBUG) printf(fmt, ##__VA_ARGS__); } while (0) |
||||
|
||||
|
||||
// base64 encoding https://nachtimwald.com/2017/11/18/base64-encode-and-decode-in-c/
|
||||
|
||||
size_t b64_encoded_size(size_t inlen) { |
||||
size_t ret; |
||||
|
||||
ret = inlen; |
||||
if (inlen % 3 != 0) |
||||
ret += 3 - (inlen % 3); |
||||
ret /= 3; |
||||
ret *= 4; |
||||
|
||||
return ret; |
||||
} |
||||
|
||||
const char b64chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; |
||||
|
||||
char *b64_encode(const unsigned char *in, size_t len) { |
||||
char *out; |
||||
size_t elen; |
||||
size_t i; |
||||
size_t j; |
||||
size_t v; |
||||
|
||||
if (in == NULL || len == 0) |
||||
return NULL; |
||||
|
||||
elen = b64_encoded_size(len); |
||||
out = malloc(elen + 1); |
||||
out[elen] = '\0'; |
||||
|
||||
for (i = 0, j = 0; i < len; i += 3, j += 4) { |
||||
v = in[i]; |
||||
v = i + 1 < len ? v << 8 | in[i + 1] : v << 8; |
||||
v = i + 2 < len ? v << 8 | in[i + 2] : v << 8; |
||||
|
||||
out[j] = b64chars[(v >> 18) & 0x3F]; |
||||
out[j + 1] = b64chars[(v >> 12) & 0x3F]; |
||||
if (i + 1 < len) { |
||||
out[j + 2] = b64chars[(v >> 6) & 0x3F]; |
||||
} else { |
||||
out[j + 2] = '='; |
||||
} |
||||
if (i + 2 < len) { |
||||
out[j + 3] = b64chars[v & 0x3F]; |
||||
} else { |
||||
out[j + 3] = '='; |
||||
} |
||||
} |
||||
|
||||
return out; |
||||
} |
||||
|
||||
|
||||
char *hashStuff(char *hashPwd) { |
||||
uint8_t hash1[HASHLEN]; |
||||
uint8_t salt[SALTLEN]; |
||||
memset(salt, 0x00, SALTLEN); |
||||
|
||||
uint8_t *pwd = (uint8_t *) strdup(PWD); |
||||
uint32_t pwdlen = strlen((char *) pwd); |
||||
|
||||
uint32_t t_cost = 2; // 1-pass computation
|
||||
uint32_t m_cost = (1 << 16); // 64 mebibytes memory usage
|
||||
uint32_t parallelism = 1; // number of threads and lanes
|
||||
argon2i_hash_raw(t_cost, m_cost, parallelism, pwd, pwdlen, salt, SALTLEN, |
||||
hash1, HASHLEN); |
||||
char *b64ret = b64_encode(hash1, HASHLEN); |
||||
return b64ret; |
||||
} |
||||
|
||||
void debugBytes(uint8_t *bytes, int length) { |
||||
PRINT_DEBUG("length: %d -- ", length); |
||||
for (int i = 0; i < length; i++) { |
||||
PRINT_DEBUG("%02x ", bytes[i]); |
||||
} |
||||
} |
||||
|
||||
char *hp_argon2_hash(uint8_t *key, size_t keylen, uint8_t *salt, size_t saltlen, |
||||
uint32_t m_cost, |
||||
uint32_t t_cost /* iterations*/, uint32_t parallelism, |
||||
size_t hashlen, |
||||
uint8_t type, int32_t version) { |
||||
uint8_t hash1[hashlen]; |
||||
PRINT_DEBUG("keylen: %ld, saltlen: %ld, m_cost: %ld, t_cost: %ld, hashlen: %ld, type: %d, version: %02x\n", |
||||
keylen, saltlen, m_cost, t_cost, hashlen, type, version); |
||||
PRINT_DEBUG("key: "); |
||||
|
||||
debugBytes(key, keylen); |
||||
PRINT_DEBUG("\n"); |
||||
|
||||
PRINT_DEBUG("salt: "); |
||||
debugBytes(salt, saltlen); |
||||
PRINT_DEBUG("\n"); |
||||
|
||||
if (type == 0) { |
||||
PRINT_DEBUG("argon2d\n"); |
||||
argon2d_hash_raw(t_cost, m_cost, parallelism, key, keylen, salt, |
||||
saltlen, |
||||
hash1, hashlen); |
||||
} else if (type == 1) { |
||||
argon2i_hash_raw(t_cost, m_cost, parallelism, key, keylen, salt, |
||||
saltlen, |
||||
hash1, hashlen); |
||||
} |
||||
|
||||
PRINT_DEBUG("hash: "); |
||||
debugBytes(hash1, hashlen); |
||||
PRINT_DEBUG("\n"); |
||||
char *b64ret = b64_encode(hash1, hashlen); |
||||
return b64ret; |
||||
} |
||||
|
||||
|
||||
|
||||
|
||||
@ -0,0 +1,3 @@
|
||||
Sources copied from https://github.com/P-H-C/phc-winner-argon2 |
||||
62358ba2123abd17fccf2a108a301d4b52c01a7c |
||||
|
||||
@ -0,0 +1,452 @@
|
||||
/*
|
||||
* 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 : http://creativecommons.org/publicdomain/zero/1.0
|
||||
* - Apache 2.0 : http://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; |
||||
} |
||||
@ -0,0 +1,437 @@
|
||||
/*
|
||||
* 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 : http://creativecommons.org/publicdomain/zero/1.0
|
||||
* - Apache 2.0 : http://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. |
||||
*/ |
||||
|
||||
#ifndef ARGON2_H |
||||
#define ARGON2_H |
||||
|
||||
#include <stdint.h> |
||||
#include <stddef.h> |
||||
#include <limits.h> |
||||
|
||||
#if defined(__cplusplus) |
||||
extern "C" { |
||||
#endif |
||||
|
||||
/* Symbols visibility control */ |
||||
#ifdef A2_VISCTL |
||||
#define ARGON2_PUBLIC __attribute__((visibility("default"))) |
||||
#define ARGON2_LOCAL __attribute__ ((visibility ("hidden"))) |
||||
#elif _MSC_VER |
||||
#define ARGON2_PUBLIC __declspec(dllexport) |
||||
#define ARGON2_LOCAL |
||||
#else |
||||
#define ARGON2_PUBLIC |
||||
#define ARGON2_LOCAL |
||||
#endif |
||||
|
||||
/*
|
||||
* Argon2 input parameter restrictions |
||||
*/ |
||||
|
||||
/* Minimum and maximum number of lanes (degree of parallelism) */ |
||||
#define ARGON2_MIN_LANES UINT32_C(1) |
||||
#define ARGON2_MAX_LANES UINT32_C(0xFFFFFF) |
||||
|
||||
/* Minimum and maximum number of threads */ |
||||
#define ARGON2_MIN_THREADS UINT32_C(1) |
||||
#define ARGON2_MAX_THREADS UINT32_C(0xFFFFFF) |
||||
|
||||
/* Number of synchronization points between lanes per pass */ |
||||
#define ARGON2_SYNC_POINTS UINT32_C(4) |
||||
|
||||
/* Minimum and maximum digest size in bytes */ |
||||
#define ARGON2_MIN_OUTLEN UINT32_C(4) |
||||
#define ARGON2_MAX_OUTLEN UINT32_C(0xFFFFFFFF) |
||||
|
||||
/* Minimum and maximum number of memory blocks (each of BLOCK_SIZE bytes) */ |
||||
#define ARGON2_MIN_MEMORY (2 * ARGON2_SYNC_POINTS) /* 2 blocks per slice */ |
||||
|
||||
#define ARGON2_MIN(a, b) ((a) < (b) ? (a) : (b)) |
||||
/* Max memory size is addressing-space/2, topping at 2^32 blocks (4 TB) */ |
||||
#define ARGON2_MAX_MEMORY_BITS \ |
||||
ARGON2_MIN(UINT32_C(32), (sizeof(void *) * CHAR_BIT - 10 - 1)) |
||||
#define ARGON2_MAX_MEMORY \ |
||||
ARGON2_MIN(UINT32_C(0xFFFFFFFF), UINT64_C(1) << ARGON2_MAX_MEMORY_BITS) |
||||
|
||||
/* Minimum and maximum number of passes */ |
||||
#define ARGON2_MIN_TIME UINT32_C(1) |
||||
#define ARGON2_MAX_TIME UINT32_C(0xFFFFFFFF) |
||||
|
||||
/* Minimum and maximum password length in bytes */ |
||||
#define ARGON2_MIN_PWD_LENGTH UINT32_C(0) |
||||
#define ARGON2_MAX_PWD_LENGTH UINT32_C(0xFFFFFFFF) |
||||
|
||||
/* Minimum and maximum associated data length in bytes */ |
||||
#define ARGON2_MIN_AD_LENGTH UINT32_C(0) |
||||
#define ARGON2_MAX_AD_LENGTH UINT32_C(0xFFFFFFFF) |
||||
|
||||
/* Minimum and maximum salt length in bytes */ |
||||
#define ARGON2_MIN_SALT_LENGTH UINT32_C(8) |
||||
#define ARGON2_MAX_SALT_LENGTH UINT32_C(0xFFFFFFFF) |
||||
|
||||
/* Minimum and maximum key length in bytes */ |
||||
#define ARGON2_MIN_SECRET UINT32_C(0) |
||||
#define ARGON2_MAX_SECRET UINT32_C(0xFFFFFFFF) |
||||
|
||||
/* Flags to determine which fields are securely wiped (default = no wipe). */ |
||||
#define ARGON2_DEFAULT_FLAGS UINT32_C(0) |
||||
#define ARGON2_FLAG_CLEAR_PASSWORD (UINT32_C(1) << 0) |
||||
#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 defaults to 1 (wipe internal memory). */ |
||||
extern int FLAG_clear_internal_memory; |
||||
|
||||
/* Error codes */ |
||||
typedef enum Argon2_ErrorCodes { |
||||
ARGON2_OK = 0, |
||||
|
||||
ARGON2_OUTPUT_PTR_NULL = -1, |
||||
|
||||
ARGON2_OUTPUT_TOO_SHORT = -2, |
||||
ARGON2_OUTPUT_TOO_LONG = -3, |
||||
|
||||
ARGON2_PWD_TOO_SHORT = -4, |
||||
ARGON2_PWD_TOO_LONG = -5, |
||||
|
||||
ARGON2_SALT_TOO_SHORT = -6, |
||||
ARGON2_SALT_TOO_LONG = -7, |
||||
|
||||
ARGON2_AD_TOO_SHORT = -8, |
||||
ARGON2_AD_TOO_LONG = -9, |
||||
|
||||
ARGON2_SECRET_TOO_SHORT = -10, |
||||
ARGON2_SECRET_TOO_LONG = -11, |
||||
|
||||
ARGON2_TIME_TOO_SMALL = -12, |
||||
ARGON2_TIME_TOO_LARGE = -13, |
||||
|
||||
ARGON2_MEMORY_TOO_LITTLE = -14, |
||||
ARGON2_MEMORY_TOO_MUCH = -15, |
||||
|
||||
ARGON2_LANES_TOO_FEW = -16, |
||||
ARGON2_LANES_TOO_MANY = -17, |
||||
|
||||
ARGON2_PWD_PTR_MISMATCH = -18, /* NULL ptr with non-zero length */ |
||||
ARGON2_SALT_PTR_MISMATCH = -19, /* NULL ptr with non-zero length */ |
||||
ARGON2_SECRET_PTR_MISMATCH = -20, /* NULL ptr with non-zero length */ |
||||
ARGON2_AD_PTR_MISMATCH = -21, /* NULL ptr with non-zero length */ |
||||
|
||||
ARGON2_MEMORY_ALLOCATION_ERROR = -22, |
||||
|
||||
ARGON2_FREE_MEMORY_CBK_NULL = -23, |
||||
ARGON2_ALLOCATE_MEMORY_CBK_NULL = -24, |
||||
|
||||
ARGON2_INCORRECT_PARAMETER = -25, |
||||
ARGON2_INCORRECT_TYPE = -26, |
||||
|
||||
ARGON2_OUT_PTR_MISMATCH = -27, |
||||
|
||||
ARGON2_THREADS_TOO_FEW = -28, |
||||
ARGON2_THREADS_TOO_MANY = -29, |
||||
|
||||
ARGON2_MISSING_ARGS = -30, |
||||
|
||||
ARGON2_ENCODING_FAIL = -31, |
||||
|
||||
ARGON2_DECODING_FAIL = -32, |
||||
|
||||
ARGON2_THREAD_FAIL = -33, |
||||
|
||||
ARGON2_DECODING_LENGTH_FAIL = -34, |
||||
|
||||
ARGON2_VERIFY_MISMATCH = -35 |
||||
} argon2_error_codes; |
||||
|
||||
/* Memory allocator types --- for external allocation */ |
||||
typedef int (*allocate_fptr)(uint8_t **memory, size_t bytes_to_allocate); |
||||
typedef void (*deallocate_fptr)(uint8_t *memory, size_t bytes_to_allocate); |
||||
|
||||
/* Argon2 external data structures */ |
||||
|
||||
/*
|
||||
***** |
||||
* Context: structure to hold Argon2 inputs: |
||||
* output array and its length, |
||||
* password and its length, |
||||
* salt and its length, |
||||
* secret and its length, |
||||
* associated data and its length, |
||||
* number of passes, amount of used memory (in KBytes, can be rounded up a bit) |
||||
* number of parallel threads that will be run. |
||||
* All the parameters above affect the output hash value. |
||||
* Additionally, two function pointers can be provided to allocate and |
||||
* deallocate the memory (if NULL, memory will be allocated internally). |
||||
* Also, three flags indicate whether to erase password, secret as soon as they |
||||
* are pre-hashed (and thus not needed anymore), and the entire memory |
||||
***** |
||||
* Simplest situation: you have output array out[8], password is stored in |
||||
* pwd[32], salt is stored in salt[16], you do not have keys nor associated |
||||
* data. You need to spend 1 GB of RAM and you run 5 passes of Argon2d with |
||||
* 4 parallel lanes. |
||||
* You want to erase the password, but you're OK with last pass not being |
||||
* erased. You want to use the default memory allocator. |
||||
* Then you initialize: |
||||
Argon2_Context(out,8,pwd,32,salt,16,NULL,0,NULL,0,5,1<<20,4,4,NULL,NULL,true,false,false,false) |
||||
*/ |
||||
typedef struct Argon2_Context { |
||||
uint8_t *out; /* output array */ |
||||
uint32_t outlen; /* digest length */ |
||||
|
||||
uint8_t *pwd; /* password array */ |
||||
uint32_t pwdlen; /* password length */ |
||||
|
||||
uint8_t *salt; /* salt array */ |
||||
uint32_t saltlen; /* salt length */ |
||||
|
||||
uint8_t *secret; /* key array */ |
||||
uint32_t secretlen; /* key length */ |
||||
|
||||
uint8_t *ad; /* associated data array */ |
||||
uint32_t adlen; /* associated data length */ |
||||
|
||||
uint32_t t_cost; /* number of passes */ |
||||
uint32_t m_cost; /* amount of memory requested (KB) */ |
||||
uint32_t lanes; /* number of lanes */ |
||||
uint32_t threads; /* maximum number of threads */ |
||||
|
||||
uint32_t version; /* version number */ |
||||
|
||||
allocate_fptr allocate_cbk; /* pointer to memory allocator */ |
||||
deallocate_fptr free_cbk; /* pointer to memory deallocator */ |
||||
|
||||
uint32_t flags; /* array of bool options */ |
||||
} argon2_context; |
||||
|
||||
/* Argon2 primitive type */ |
||||
typedef enum Argon2_type { |
||||
Argon2_d = 0, |
||||
Argon2_i = 1, |
||||
Argon2_id = 2 |
||||
} argon2_type; |
||||
|
||||
/* Version of the algorithm */ |
||||
typedef enum Argon2_version { |
||||
ARGON2_VERSION_10 = 0x10, |
||||
ARGON2_VERSION_13 = 0x13, |
||||
ARGON2_VERSION_NUMBER = ARGON2_VERSION_13 |
||||
} argon2_version; |
||||
|
||||
/*
|
||||
* Function that gives the string representation of an argon2_type. |
||||
* @param type The argon2_type that we want the string for |
||||
* @param uppercase Whether the string should have the first letter uppercase |
||||
* @return NULL if invalid type, otherwise the string representation. |
||||
*/ |
||||
ARGON2_PUBLIC const char *argon2_type2string(argon2_type type, int uppercase); |
||||
|
||||
/*
|
||||
* 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 |
||||
*/ |
||||
ARGON2_PUBLIC int argon2_ctx(argon2_context *context, argon2_type type); |
||||
|
||||
/**
|
||||
* Hashes a password with Argon2i, producing an encoded hash |
||||
* @param t_cost Number of iterations |
||||
* @param m_cost Sets memory usage to m_cost kibibytes |
||||
* @param parallelism Number of threads and compute lanes |
||||
* @param pwd Pointer to password |
||||
* @param pwdlen Password size in bytes |
||||
* @param salt Pointer to salt |
||||
* @param saltlen Salt size in bytes |
||||
* @param hashlen Desired length of the hash in bytes |
||||
* @param encoded Buffer where to write the encoded hash |
||||
* @param encodedlen Size of the buffer (thus max size of the encoded hash) |
||||
* @pre Different parallelism levels will give different results |
||||
* @pre Returns ARGON2_OK if successful |
||||
*/ |
||||
ARGON2_PUBLIC 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); |
||||
|
||||
/**
|
||||
* Hashes a password with Argon2i, producing a raw hash at @hash |
||||
* @param t_cost Number of iterations |
||||
* @param m_cost Sets memory usage to m_cost kibibytes |
||||
* @param parallelism Number of threads and compute lanes |
||||
* @param pwd Pointer to password |
||||
* @param pwdlen Password size in bytes |
||||
* @param salt Pointer to salt |
||||
* @param saltlen Salt size in bytes |
||||
* @param hash Buffer where to write the raw hash - updated by the function |
||||
* @param hashlen Desired length of the hash in bytes |
||||
* @pre Different parallelism levels will give different results |
||||
* @pre Returns ARGON2_OK if successful |
||||
*/ |
||||
ARGON2_PUBLIC 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); |
||||
|
||||
ARGON2_PUBLIC 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); |
||||
|
||||
ARGON2_PUBLIC 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); |
||||
|
||||
ARGON2_PUBLIC 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); |
||||
|
||||
ARGON2_PUBLIC 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); |
||||
|
||||
/* generic function underlying the above ones */ |
||||
ARGON2_PUBLIC 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); |
||||
|
||||
/**
|
||||
* Verifies a password against an encoded string |
||||
* Encoded string is restricted as in validate_inputs() |
||||
* @param encoded String encoding parameters, salt, hash |
||||
* @param pwd Pointer to password |
||||
* @pre Returns ARGON2_OK if successful |
||||
*/ |
||||
ARGON2_PUBLIC int argon2i_verify(const char *encoded, const void *pwd, |
||||
const size_t pwdlen); |
||||
|
||||
ARGON2_PUBLIC int argon2d_verify(const char *encoded, const void *pwd, |
||||
const size_t pwdlen); |
||||
|
||||
ARGON2_PUBLIC int argon2id_verify(const char *encoded, const void *pwd, |
||||
const size_t pwdlen); |
||||
|
||||
/* generic function underlying the above ones */ |
||||
ARGON2_PUBLIC int argon2_verify(const char *encoded, const void *pwd, |
||||
const size_t pwdlen, argon2_type type); |
||||
|
||||
/**
|
||||
* Argon2d: Version of Argon2 that picks memory blocks depending |
||||
* on the password and salt. Only for side-channel-free |
||||
* environment!! |
||||
***** |
||||
* @param context Pointer to current Argon2 context |
||||
* @return Zero if successful, a non zero error code otherwise |
||||
*/ |
||||
ARGON2_PUBLIC int argon2d_ctx(argon2_context *context); |
||||
|
||||
/**
|
||||
* Argon2i: Version of Argon2 that picks memory blocks |
||||
* independent on the password and salt. Good for side-channels, |
||||
* but worse w.r.t. tradeoff attacks if only one pass is used. |
||||
***** |
||||
* @param context Pointer to current Argon2 context |
||||
* @return Zero if successful, a non zero error code otherwise |
||||
*/ |
||||
ARGON2_PUBLIC int argon2i_ctx(argon2_context *context); |
||||
|
||||
/**
|
||||
* Argon2id: Version of Argon2 where the first half-pass over memory is |
||||
* password-independent, the rest are password-dependent (on the password and |
||||
* salt). OK against side channels (they reduce to 1/2-pass Argon2i), and |
||||
* better with w.r.t. tradeoff attacks (similar to Argon2d). |
||||
***** |
||||
* @param context Pointer to current Argon2 context |
||||
* @return Zero if successful, a non zero error code otherwise |
||||
*/ |
||||
ARGON2_PUBLIC int argon2id_ctx(argon2_context *context); |
||||
|
||||
/**
|
||||
* Verify if a given password is correct for Argon2d 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 |
||||
*/ |
||||
ARGON2_PUBLIC int argon2d_verify_ctx(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 |
||||
*/ |
||||
ARGON2_PUBLIC int argon2i_verify_ctx(argon2_context *context, const char *hash); |
||||
|
||||
/**
|
||||
* Verify if a given password is correct for Argon2id 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 |
||||
*/ |
||||
ARGON2_PUBLIC int argon2id_verify_ctx(argon2_context *context, |
||||
const char *hash); |
||||
|
||||
/* generic function underlying the above ones */ |
||||
ARGON2_PUBLIC int argon2_verify_ctx(argon2_context *context, const char *hash, |
||||
argon2_type type); |
||||
|
||||
/**
|
||||
* Get the associated error message for given error code |
||||
* @return The error message associated with the given error code |
||||
*/ |
||||
ARGON2_PUBLIC const char *argon2_error_message(int error_code); |
||||
|
||||
/**
|
||||
* Returns the encoded hash length for the given input parameters |
||||
* @param t_cost Number of iterations |
||||
* @param m_cost Memory usage in kibibytes |
||||
* @param parallelism Number of threads; used to compute lanes |
||||
* @param saltlen Salt size in bytes |
||||
* @param hashlen Hash size in bytes |
||||
* @param type The argon2_type that we want the encoded length for |
||||
* @return The encoded hash length in bytes |
||||
*/ |
||||
ARGON2_PUBLIC size_t argon2_encodedlen(uint32_t t_cost, uint32_t m_cost, |
||||
uint32_t parallelism, uint32_t saltlen, |
||||
uint32_t hashlen, argon2_type type); |
||||
|
||||
#if defined(__cplusplus) |
||||
} |
||||
#endif |
||||
|
||||
#endif |
||||
@ -0,0 +1,156 @@
|
||||
/*
|
||||
* 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 : http://creativecommons.org/publicdomain/zero/1.0
|
||||
* - Apache 2.0 : http://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. |
||||
*/ |
||||
|
||||
#ifndef PORTABLE_BLAKE2_IMPL_H |
||||
#define PORTABLE_BLAKE2_IMPL_H |
||||
|
||||
#include <stdint.h> |
||||
#include <string.h> |
||||
|
||||
#if defined(_MSC_VER) |
||||
#define BLAKE2_INLINE __inline |
||||
#elif defined(__GNUC__) || defined(__clang__) |
||||
#define BLAKE2_INLINE __inline__ |
||||
#else |
||||
#define BLAKE2_INLINE |
||||
#endif |
||||
|
||||
/* Argon2 Team - Begin Code */ |
||||
/*
|
||||
Not an exhaustive list, but should cover the majority of modern platforms |
||||
Additionally, the code will always be correct---this is only a performance |
||||
tweak. |
||||
*/ |
||||
#if (defined(__BYTE_ORDER__) && \ |
||||
(__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)) || \
|
||||
defined(__LITTLE_ENDIAN__) || defined(__ARMEL__) || defined(__MIPSEL__) || \
|
||||
defined(__AARCH64EL__) || defined(__amd64__) || defined(__i386__) || \
|
||||
defined(_M_IX86) || defined(_M_X64) || defined(_M_AMD64) || \
|
||||
defined(_M_ARM) |
||||
#define NATIVE_LITTLE_ENDIAN |
||||
#endif |
||||
/* Argon2 Team - End Code */ |
||||
|
||||
static BLAKE2_INLINE uint32_t load32(const void *src) { |
||||
#if defined(NATIVE_LITTLE_ENDIAN) |
||||
uint32_t w; |
||||
memcpy(&w, src, sizeof w); |
||||
return w; |
||||
#else |
||||
const uint8_t *p = (const uint8_t *)src; |
||||
uint32_t w = *p++; |
||||
w |= (uint32_t)(*p++) << 8; |
||||
w |= (uint32_t)(*p++) << 16; |
||||
w |= (uint32_t)(*p++) << 24; |
||||
return w; |
||||
#endif |
||||
} |
||||
|
||||
static BLAKE2_INLINE uint64_t load64(const void *src) { |
||||
#if defined(NATIVE_LITTLE_ENDIAN) |
||||
uint64_t w; |
||||
memcpy(&w, src, sizeof w); |
||||
return w; |
||||
#else |
||||
const uint8_t *p = (const uint8_t *)src; |
||||
uint64_t w = *p++; |
||||
w |= (uint64_t)(*p++) << 8; |
||||
w |= (uint64_t)(*p++) << 16; |
||||
w |= (uint64_t)(*p++) << 24; |
||||
w |= (uint64_t)(*p++) << 32; |
||||
w |= (uint64_t)(*p++) << 40; |
||||
w |= (uint64_t)(*p++) << 48; |
||||
w |= (uint64_t)(*p++) << 56; |
||||
return w; |
||||
#endif |
||||
} |
||||
|
||||
static BLAKE2_INLINE void store32(void *dst, uint32_t w) { |
||||
#if defined(NATIVE_LITTLE_ENDIAN) |
||||
memcpy(dst, &w, sizeof w); |
||||
#else |
||||
uint8_t *p = (uint8_t *)dst; |
||||
*p++ = (uint8_t)w; |
||||
w >>= 8; |
||||
*p++ = (uint8_t)w; |
||||
w >>= 8; |
||||
*p++ = (uint8_t)w; |
||||
w >>= 8; |
||||
*p++ = (uint8_t)w; |
||||
#endif |
||||
} |
||||
|
||||
static BLAKE2_INLINE void store64(void *dst, uint64_t w) { |
||||
#if defined(NATIVE_LITTLE_ENDIAN) |
||||
memcpy(dst, &w, sizeof w); |
||||
#else |
||||
uint8_t *p = (uint8_t *)dst; |
||||
*p++ = (uint8_t)w; |
||||
w >>= 8; |
||||
*p++ = (uint8_t)w; |
||||
w >>= 8; |
||||
*p++ = (uint8_t)w; |
||||
w >>= 8; |
||||
*p++ = (uint8_t)w; |
||||
w >>= 8; |
||||
*p++ = (uint8_t)w; |
||||
w >>= 8; |
||||
*p++ = (uint8_t)w; |
||||
w >>= 8; |
||||
*p++ = (uint8_t)w; |
||||
w >>= 8; |
||||
*p++ = (uint8_t)w; |
||||
#endif |
||||
} |
||||
|
||||
static BLAKE2_INLINE uint64_t load48(const void *src) { |
||||
const uint8_t *p = (const uint8_t *)src; |
||||
uint64_t w = *p++; |
||||
w |= (uint64_t)(*p++) << 8; |
||||
w |= (uint64_t)(*p++) << 16; |
||||
w |= (uint64_t)(*p++) << 24; |
||||
w |= (uint64_t)(*p++) << 32; |
||||
w |= (uint64_t)(*p++) << 40; |
||||
return w; |
||||
} |
||||
|
||||
static BLAKE2_INLINE void store48(void *dst, uint64_t w) { |
||||
uint8_t *p = (uint8_t *)dst; |
||||
*p++ = (uint8_t)w; |
||||
w >>= 8; |
||||
*p++ = (uint8_t)w; |
||||
w >>= 8; |
||||
*p++ = (uint8_t)w; |
||||
w >>= 8; |
||||
*p++ = (uint8_t)w; |
||||
w >>= 8; |
||||
*p++ = (uint8_t)w; |
||||
w >>= 8; |
||||
*p++ = (uint8_t)w; |
||||
} |
||||
|
||||
static BLAKE2_INLINE uint32_t rotr32(const uint32_t w, const unsigned c) { |
||||
return (w >> c) | (w << (32 - c)); |
||||
} |
||||
|
||||
static BLAKE2_INLINE uint64_t rotr64(const uint64_t w, const unsigned c) { |
||||
return (w >> c) | (w << (64 - c)); |
||||
} |
||||
|
||||
void clear_internal_memory(void *v, size_t n); |
||||
|
||||
#endif |
||||
@ -0,0 +1,89 @@
|
||||
/*
|
||||
* 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 : http://creativecommons.org/publicdomain/zero/1.0
|
||||
* - Apache 2.0 : http://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. |
||||
*/ |
||||
|
||||
#ifndef PORTABLE_BLAKE2_H |
||||
#define PORTABLE_BLAKE2_H |
||||
|
||||
#include "../argon2.h" |
||||
|
||||
#if defined(__cplusplus) |
||||
extern "C" { |
||||
#endif |
||||
|
||||
enum blake2b_constant { |
||||
BLAKE2B_BLOCKBYTES = 128, |
||||
BLAKE2B_OUTBYTES = 64, |
||||
BLAKE2B_KEYBYTES = 64, |
||||
BLAKE2B_SALTBYTES = 16, |
||||
BLAKE2B_PERSONALBYTES = 16 |
||||
}; |
||||
|
||||
#pragma pack(push, 1) |
||||
typedef struct __blake2b_param { |
||||
uint8_t digest_length; /* 1 */ |
||||
uint8_t key_length; /* 2 */ |
||||
uint8_t fanout; /* 3 */ |
||||
uint8_t depth; /* 4 */ |
||||
uint32_t leaf_length; /* 8 */ |
||||
uint64_t node_offset; /* 16 */ |
||||
uint8_t node_depth; /* 17 */ |
||||
uint8_t inner_length; /* 18 */ |
||||
uint8_t reserved[14]; /* 32 */ |
||||
uint8_t salt[BLAKE2B_SALTBYTES]; /* 48 */ |
||||
uint8_t personal[BLAKE2B_PERSONALBYTES]; /* 64 */ |
||||
} blake2b_param; |
||||
#pragma pack(pop) |
||||
|
||||
typedef struct __blake2b_state { |
||||
uint64_t h[8]; |
||||
uint64_t t[2]; |
||||
uint64_t f[2]; |
||||
uint8_t buf[BLAKE2B_BLOCKBYTES]; |
||||
unsigned buflen; |
||||
unsigned outlen; |
||||
uint8_t last_node; |
||||
} blake2b_state; |
||||
|
||||
/* Ensure param structs have not been wrongly padded */ |
||||
/* Poor man's static_assert */ |
||||
enum { |
||||
blake2_size_check_0 = 1 / !!(CHAR_BIT == 8), |
||||
blake2_size_check_2 = |
||||
1 / !!(sizeof(blake2b_param) == sizeof(uint64_t) * CHAR_BIT) |
||||
}; |
||||
|
||||
/* Streaming API */ |
||||
ARGON2_LOCAL int blake2b_init(blake2b_state *S, size_t outlen); |
||||
ARGON2_LOCAL int blake2b_init_key(blake2b_state *S, size_t outlen, const void *key, |
||||
size_t keylen); |
||||
ARGON2_LOCAL int blake2b_init_param(blake2b_state *S, const blake2b_param *P); |
||||
ARGON2_LOCAL int blake2b_update(blake2b_state *S, const void *in, size_t inlen); |
||||
ARGON2_LOCAL int blake2b_final(blake2b_state *S, void *out, size_t outlen); |
||||
|
||||
/* Simple API */ |
||||
ARGON2_LOCAL int blake2b(void *out, size_t outlen, const void *in, size_t inlen, |
||||
const void *key, size_t keylen); |
||||
|
||||
/* Argon2 Team - Begin Code */ |
||||
ARGON2_LOCAL int blake2b_long(void *out, size_t outlen, const void *in, size_t inlen); |
||||
/* Argon2 Team - End Code */ |
||||
|
||||
#if defined(__cplusplus) |
||||
} |
||||
#endif |
||||
|
||||
#endif |
||||
@ -0,0 +1,390 @@
|
||||
/*
|
||||
* 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 : http://creativecommons.org/publicdomain/zero/1.0
|
||||
* - Apache 2.0 : http://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 <stdint.h> |
||||
#include <string.h> |
||||
#include <stdio.h> |
||||
|
||||
#include "blake2.h" |
||||
#include "blake2-impl.h" |
||||
|
||||
static const uint64_t blake2b_IV[8] = { |
||||
UINT64_C(0x6a09e667f3bcc908), UINT64_C(0xbb67ae8584caa73b), |
||||
UINT64_C(0x3c6ef372fe94f82b), UINT64_C(0xa54ff53a5f1d36f1), |
||||
UINT64_C(0x510e527fade682d1), UINT64_C(0x9b05688c2b3e6c1f), |
||||
UINT64_C(0x1f83d9abfb41bd6b), UINT64_C(0x5be0cd19137e2179)}; |
||||
|
||||
static const unsigned int blake2b_sigma[12][16] = { |
||||
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}, |
||||
{14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3}, |
||||
{11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4}, |
||||
{7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8}, |
||||
{9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13}, |
||||
{2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9}, |
||||
{12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11}, |
||||
{13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10}, |
||||
{6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5}, |
||||
{10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0}, |
||||
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}, |
||||
{14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3}, |
||||
}; |
||||
|
||||
static BLAKE2_INLINE void blake2b_set_lastnode(blake2b_state *S) { |
||||
S->f[1] = (uint64_t)-1; |
||||
} |
||||
|
||||
static BLAKE2_INLINE void blake2b_set_lastblock(blake2b_state *S) { |
||||
if (S->last_node) { |
||||
blake2b_set_lastnode(S); |
||||
} |
||||
S->f[0] = (uint64_t)-1; |
||||
} |
||||
|
||||
static BLAKE2_INLINE void blake2b_increment_counter(blake2b_state *S, |
||||
uint64_t inc) { |
||||
S->t[0] += inc; |
||||
S->t[1] += (S->t[0] < inc); |
||||
} |
||||
|
||||
static BLAKE2_INLINE void blake2b_invalidate_state(blake2b_state *S) { |
||||
clear_internal_memory(S, sizeof(*S)); /* wipe */ |
||||
blake2b_set_lastblock(S); /* invalidate for further use */ |
||||
} |
||||
|
||||
static BLAKE2_INLINE void blake2b_init0(blake2b_state *S) { |
||||
memset(S, 0, sizeof(*S)); |
||||
memcpy(S->h, blake2b_IV, sizeof(S->h)); |
||||
} |
||||
|
||||
int blake2b_init_param(blake2b_state *S, const blake2b_param *P) { |
||||
const unsigned char *p = (const unsigned char *)P; |
||||
unsigned int i; |
||||
|
||||
if (NULL == P || NULL == S) { |
||||
return -1; |
||||
} |
||||
|
||||
blake2b_init0(S); |
||||
/* IV XOR Parameter Block */ |
||||
for (i = 0; i < 8; ++i) { |
||||
S->h[i] ^= load64(&p[i * sizeof(S->h[i])]); |
||||
} |
||||
S->outlen = P->digest_length; |
||||
return 0; |
||||
} |
||||
|
||||
/* Sequential blake2b initialization */ |
||||
int blake2b_init(blake2b_state *S, size_t outlen) { |
||||
blake2b_param P; |
||||
|
||||
if (S == NULL) { |
||||
return -1; |
||||
} |
||||
|
||||
if ((outlen == 0) || (outlen > BLAKE2B_OUTBYTES)) { |
||||
blake2b_invalidate_state(S); |
||||
return -1; |
||||
} |
||||
|
||||
/* Setup Parameter Block for unkeyed BLAKE2 */ |
||||
P.digest_length = (uint8_t)outlen; |
||||
P.key_length = 0; |
||||
P.fanout = 1; |
||||
P.depth = 1; |
||||
P.leaf_length = 0; |
||||
P.node_offset = 0; |
||||
P.node_depth = 0; |
||||
P.inner_length = 0; |
||||
memset(P.reserved, 0, sizeof(P.reserved)); |
||||
memset(P.salt, 0, sizeof(P.salt)); |
||||
memset(P.personal, 0, sizeof(P.personal)); |
||||
|
||||
return blake2b_init_param(S, &P); |
||||
} |
||||
|
||||
int blake2b_init_key(blake2b_state *S, size_t outlen, const void *key, |
||||
size_t keylen) { |
||||
blake2b_param P; |
||||
|
||||
if (S == NULL) { |
||||
return -1; |
||||
} |
||||
|
||||
if ((outlen == 0) || (outlen > BLAKE2B_OUTBYTES)) { |
||||
blake2b_invalidate_state(S); |
||||
return -1; |
||||
} |
||||
|
||||
if ((key == 0) || (keylen == 0) || (keylen > BLAKE2B_KEYBYTES)) { |
||||
blake2b_invalidate_state(S); |
||||
return -1; |
||||
} |
||||
|
||||
/* Setup Parameter Block for keyed BLAKE2 */ |
||||
P.digest_length = (uint8_t)outlen; |
||||
P.key_length = (uint8_t)keylen; |
||||
P.fanout = 1; |
||||
P.depth = 1; |
||||
P.leaf_length = 0; |
||||
P.node_offset = 0; |
||||
P.node_depth = 0; |
||||
P.inner_length = 0; |
||||
memset(P.reserved, 0, sizeof(P.reserved)); |
||||
memset(P.salt, 0, sizeof(P.salt)); |
||||
memset(P.personal, 0, sizeof(P.personal)); |
||||
|
||||
if (blake2b_init_param(S, &P) < 0) { |
||||
blake2b_invalidate_state(S); |
||||
return -1; |
||||
} |
||||
|
||||
{ |
||||
uint8_t block[BLAKE2B_BLOCKBYTES]; |
||||
memset(block, 0, BLAKE2B_BLOCKBYTES); |
||||
memcpy(block, key, keylen); |
||||
blake2b_update(S, block, BLAKE2B_BLOCKBYTES); |
||||
/* Burn the key from stack */ |
||||
clear_internal_memory(block, BLAKE2B_BLOCKBYTES); |
||||
} |
||||
return 0; |
||||
} |
||||
|
||||
static void blake2b_compress(blake2b_state *S, const uint8_t *block) { |
||||
uint64_t m[16]; |
||||
uint64_t v[16]; |
||||
unsigned int i, r; |
||||
|
||||
for (i = 0; i < 16; ++i) { |
||||
m[i] = load64(block + i * sizeof(m[i])); |
||||
} |
||||
|
||||
for (i = 0; i < 8; ++i) { |
||||
v[i] = S->h[i]; |
||||
} |
||||
|
||||
v[8] = blake2b_IV[0]; |
||||
v[9] = blake2b_IV[1]; |
||||
v[10] = blake2b_IV[2]; |
||||
v[11] = blake2b_IV[3]; |
||||
v[12] = blake2b_IV[4] ^ S->t[0]; |
||||
v[13] = blake2b_IV[5] ^ S->t[1]; |
||||
v[14] = blake2b_IV[6] ^ S->f[0]; |
||||
v[15] = blake2b_IV[7] ^ S->f[1]; |
||||
|
||||
#define G(r, i, a, b, c, d) \ |
||||
do { \
|
||||
a = a + b + m[blake2b_sigma[r][2 * i + 0]]; \
|
||||
d = rotr64(d ^ a, 32); \
|
||||
c = c + d; \
|
||||
b = rotr64(b ^ c, 24); \
|
||||
a = a + b + m[blake2b_sigma[r][2 * i + 1]]; \
|
||||
d = rotr64(d ^ a, 16); \
|
||||
c = c + d; \
|
||||
b = rotr64(b ^ c, 63); \
|
||||
} while ((void)0, 0) |
||||
|
||||
#define ROUND(r) \ |
||||
do { \
|
||||
G(r, 0, v[0], v[4], v[8], v[12]); \
|
||||
G(r, 1, v[1], v[5], v[9], v[13]); \
|
||||
G(r, 2, v[2], v[6], v[10], v[14]); \
|
||||
G(r, 3, v[3], v[7], v[11], v[15]); \
|
||||
G(r, 4, v[0], v[5], v[10], v[15]); \
|
||||
G(r, 5, v[1], v[6], v[11], v[12]); \
|
||||
G(r, 6, v[2], v[7], v[8], v[13]); \
|
||||
G(r, 7, v[3], v[4], v[9], v[14]); \
|
||||
} while ((void)0, 0) |
||||
|
||||
for (r = 0; r < 12; ++r) { |
||||
ROUND(r); |
||||
} |
||||
|
||||
for (i = 0; i < 8; ++i) { |
||||
S->h[i] = S->h[i] ^ v[i] ^ v[i + 8]; |
||||
} |
||||
|
||||
#undef G |
||||
#undef ROUND |
||||
} |
||||
|
||||
int blake2b_update(blake2b_state *S, const void *in, size_t inlen) { |
||||
const uint8_t *pin = (const uint8_t *)in; |
||||
|
||||
if (inlen == 0) { |
||||
return 0; |
||||
} |
||||
|
||||
/* Sanity check */ |
||||
if (S == NULL || in == NULL) { |
||||
return -1; |
||||
} |
||||
|
||||
/* Is this a reused state? */ |
||||
if (S->f[0] != 0) { |
||||
return -1; |
||||
} |
||||
|
||||
if (S->buflen + inlen > BLAKE2B_BLOCKBYTES) { |
||||
/* Complete current block */ |
||||
size_t left = S->buflen; |
||||
size_t fill = BLAKE2B_BLOCKBYTES - left; |
||||
memcpy(&S->buf[left], pin, fill); |
||||
blake2b_increment_counter(S, BLAKE2B_BLOCKBYTES); |
||||
blake2b_compress(S, S->buf); |
||||
S->buflen = 0; |
||||
inlen -= fill; |
||||
pin += fill; |
||||
/* Avoid buffer copies when possible */ |
||||
while (inlen > BLAKE2B_BLOCKBYTES) { |
||||
blake2b_increment_counter(S, BLAKE2B_BLOCKBYTES); |
||||
blake2b_compress(S, pin); |
||||
inlen -= BLAKE2B_BLOCKBYTES; |
||||
pin += BLAKE2B_BLOCKBYTES; |
||||
} |
||||
} |
||||
memcpy(&S->buf[S->buflen], pin, inlen); |
||||
S->buflen += (unsigned int)inlen; |
||||
return 0; |
||||
} |
||||
|
||||
int blake2b_final(blake2b_state *S, void *out, size_t outlen) { |
||||
uint8_t buffer[BLAKE2B_OUTBYTES] = {0}; |
||||
unsigned int i; |
||||
|
||||
/* Sanity checks */ |
||||
if (S == NULL || out == NULL || outlen < S->outlen) { |
||||
return -1; |
||||
} |
||||
|
||||
/* Is this a reused state? */ |
||||
if (S->f[0] != 0) { |
||||
return -1; |
||||
} |
||||
|
||||
blake2b_increment_counter(S, S->buflen); |
||||
blake2b_set_lastblock(S); |
||||
memset(&S->buf[S->buflen], 0, BLAKE2B_BLOCKBYTES - S->buflen); /* Padding */ |
||||
blake2b_compress(S, S->buf); |
||||
|
||||
for (i = 0; i < 8; ++i) { /* Output full hash to temp buffer */ |
||||
store64(buffer + sizeof(S->h[i]) * i, S->h[i]); |
||||
} |
||||
|
||||
memcpy(out, buffer, S->outlen); |
||||
clear_internal_memory(buffer, sizeof(buffer)); |
||||
clear_internal_memory(S->buf, sizeof(S->buf)); |
||||
clear_internal_memory(S->h, sizeof(S->h)); |
||||
return 0; |
||||
} |
||||
|
||||
int blake2b(void *out, size_t outlen, const void *in, size_t inlen, |
||||
const void *key, size_t keylen) { |
||||
blake2b_state S; |
||||
int ret = -1; |
||||
|
||||
/* Verify parameters */ |
||||
if (NULL == in && inlen > 0) { |
||||
goto fail; |
||||
} |
||||
|
||||
if (NULL == out || outlen == 0 || outlen > BLAKE2B_OUTBYTES) { |
||||
goto fail; |
||||
} |
||||
|
||||
if ((NULL == key && keylen > 0) || keylen > BLAKE2B_KEYBYTES) { |
||||
goto fail; |
||||
} |
||||
|
||||
if (keylen > 0) { |
||||
if (blake2b_init_key(&S, outlen, key, keylen) < 0) { |
||||
goto fail; |
||||
} |
||||
} else { |
||||
if (blake2b_init(&S, outlen) < 0) { |
||||
goto fail; |
||||
} |
||||
} |
||||
|
||||
if (blake2b_update(&S, in, inlen) < 0) { |
||||
goto fail; |
||||
} |
||||
ret = blake2b_final(&S, out, outlen); |
||||
|
||||
fail: |
||||
clear_internal_memory(&S, sizeof(S)); |
||||
return ret; |
||||
} |
||||
|
||||
/* Argon2 Team - Begin Code */ |
||||
int blake2b_long(void *pout, size_t outlen, const void *in, size_t inlen) { |
||||
uint8_t *out = (uint8_t *)pout; |
||||
blake2b_state blake_state; |
||||
uint8_t outlen_bytes[sizeof(uint32_t)] = {0}; |
||||
int ret = -1; |
||||
|
||||
if (outlen > UINT32_MAX) { |
||||
goto fail; |
||||
} |
||||
|
||||
/* Ensure little-endian byte order! */ |
||||
store32(outlen_bytes, (uint32_t)outlen); |
||||
|
||||
#define TRY(statement) \ |
||||
do { \
|
||||
ret = statement; \
|
||||
if (ret < 0) { \
|
||||
goto fail; \
|
||||
} \
|
||||
} while ((void)0, 0) |
||||
|
||||
if (outlen <= BLAKE2B_OUTBYTES) { |
||||
TRY(blake2b_init(&blake_state, outlen)); |
||||
TRY(blake2b_update(&blake_state, outlen_bytes, sizeof(outlen_bytes))); |
||||
TRY(blake2b_update(&blake_state, in, inlen)); |
||||
TRY(blake2b_final(&blake_state, out, outlen)); |
||||
} else { |
||||
uint32_t toproduce; |
||||
uint8_t out_buffer[BLAKE2B_OUTBYTES]; |
||||
uint8_t in_buffer[BLAKE2B_OUTBYTES]; |
||||
TRY(blake2b_init(&blake_state, BLAKE2B_OUTBYTES)); |
||||
TRY(blake2b_update(&blake_state, outlen_bytes, sizeof(outlen_bytes))); |
||||
TRY(blake2b_update(&blake_state, in, inlen)); |
||||
TRY(blake2b_final(&blake_state, out_buffer, BLAKE2B_OUTBYTES)); |
||||
memcpy(out, out_buffer, BLAKE2B_OUTBYTES / 2); |
||||
out += BLAKE2B_OUTBYTES / 2; |
||||
toproduce = (uint32_t)outlen - BLAKE2B_OUTBYTES / 2; |
||||
|
||||
while (toproduce > BLAKE2B_OUTBYTES) { |
||||
memcpy(in_buffer, out_buffer, BLAKE2B_OUTBYTES); |
||||
TRY(blake2b(out_buffer, BLAKE2B_OUTBYTES, in_buffer, |
||||
BLAKE2B_OUTBYTES, NULL, 0)); |
||||
memcpy(out, out_buffer, BLAKE2B_OUTBYTES / 2); |
||||
out += BLAKE2B_OUTBYTES / 2; |
||||
toproduce -= BLAKE2B_OUTBYTES / 2; |
||||
} |
||||
|
||||
memcpy(in_buffer, out_buffer, BLAKE2B_OUTBYTES); |
||||
TRY(blake2b(out_buffer, toproduce, in_buffer, BLAKE2B_OUTBYTES, NULL, |
||||
0)); |
||||
memcpy(out, out_buffer, toproduce); |
||||
} |
||||
fail: |
||||
clear_internal_memory(&blake_state, sizeof(blake_state)); |
||||
return ret; |
||||
#undef TRY |
||||
} |
||||
/* Argon2 Team - End Code */ |
||||
@ -0,0 +1,471 @@
|
||||
/*
|
||||
* 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 : http://creativecommons.org/publicdomain/zero/1.0
|
||||
* - Apache 2.0 : http://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. |
||||
*/ |
||||
|
||||
#ifndef BLAKE_ROUND_MKA_OPT_H |
||||
#define BLAKE_ROUND_MKA_OPT_H |
||||
|
||||
#include "blake2-impl.h" |
||||
|
||||
#include <emmintrin.h> |
||||
#if defined(__SSSE3__) |
||||
#include <tmmintrin.h> /* for _mm_shuffle_epi8 and _mm_alignr_epi8 */ |
||||
#endif |
||||
|
||||
#if defined(__XOP__) && (defined(__GNUC__) || defined(__clang__)) |
||||
#include <x86intrin.h> |
||||
#endif |
||||
|
||||
#if !defined(__AVX512F__) |
||||
#if !defined(__AVX2__) |
||||
#if !defined(__XOP__) |
||||
#if defined(__SSSE3__) |
||||
#define r16 \ |
||||
(_mm_setr_epi8(2, 3, 4, 5, 6, 7, 0, 1, 10, 11, 12, 13, 14, 15, 8, 9)) |
||||
#define r24 \ |
||||
(_mm_setr_epi8(3, 4, 5, 6, 7, 0, 1, 2, 11, 12, 13, 14, 15, 8, 9, 10)) |
||||
#define _mm_roti_epi64(x, c) \ |
||||
(-(c) == 32) \
|
||||
? _mm_shuffle_epi32((x), _MM_SHUFFLE(2, 3, 0, 1)) \
|
||||
: (-(c) == 24) \
|
||||
? _mm_shuffle_epi8((x), r24) \
|
||||
: (-(c) == 16) \
|
||||
? _mm_shuffle_epi8((x), r16) \
|
||||
: (-(c) == 63) \
|
||||
? _mm_xor_si128(_mm_srli_epi64((x), -(c)), \
|
||||
_mm_add_epi64((x), (x))) \
|
||||
: _mm_xor_si128(_mm_srli_epi64((x), -(c)), \
|
||||
_mm_slli_epi64((x), 64 - (-(c)))) |
||||
#else /* defined(__SSE2__) */ |
||||
#define _mm_roti_epi64(r, c) \ |
||||
_mm_xor_si128(_mm_srli_epi64((r), -(c)), _mm_slli_epi64((r), 64 - (-(c)))) |
||||
#endif |
||||
#else |
||||
#endif |
||||
|
||||
static BLAKE2_INLINE __m128i fBlaMka(__m128i x, __m128i y) { |
||||
const __m128i z = _mm_mul_epu32(x, y); |
||||
return _mm_add_epi64(_mm_add_epi64(x, y), _mm_add_epi64(z, z)); |
||||
} |
||||
|
||||
#define G1(A0, B0, C0, D0, A1, B1, C1, D1) \ |
||||
do { \
|
||||
A0 = fBlaMka(A0, B0); \
|
||||
A1 = fBlaMka(A1, B1); \
|
||||
\
|
||||
D0 = _mm_xor_si128(D0, A0); \
|
||||
D1 = _mm_xor_si128(D1, A1); \
|
||||
\
|
||||
D0 = _mm_roti_epi64(D0, -32); \
|
||||
D1 = _mm_roti_epi64(D1, -32); \
|
||||
\
|
||||
C0 = fBlaMka(C0, D0); \
|
||||
C1 = fBlaMka(C1, D1); \
|
||||
\
|
||||
B0 = _mm_xor_si128(B0, C0); \
|
||||
B1 = _mm_xor_si128(B1, C1); \
|
||||
\
|
||||
B0 = _mm_roti_epi64(B0, -24); \
|
||||
B1 = _mm_roti_epi64(B1, -24); \
|
||||
} while ((void)0, 0) |
||||
|
||||
#define G2(A0, B0, C0, D0, A1, B1, C1, D1) \ |
||||
do { \
|
||||
A0 = fBlaMka(A0, B0); \
|
||||
A1 = fBlaMka(A1, B1); \
|
||||
\
|
||||
D0 = _mm_xor_si128(D0, A0); \
|
||||
D1 = _mm_xor_si128(D1, A1); \
|
||||
\
|
||||
D0 = _mm_roti_epi64(D0, -16); \
|
||||
D1 = _mm_roti_epi64(D1, -16); \
|
||||
\
|
||||
C0 = fBlaMka(C0, D0); \
|
||||
C1 = fBlaMka(C1, D1); \
|
||||
\
|
||||
B0 = _mm_xor_si128(B0, C0); \
|
||||
B1 = _mm_xor_si128(B1, C1); \
|
||||
\
|
||||
B0 = _mm_roti_epi64(B0, -63); \
|
||||
B1 = _mm_roti_epi64(B1, -63); \
|
||||
} while ((void)0, 0) |
||||
|
||||
#if defined(__SSSE3__) |
||||
#define DIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1) \ |
||||
do { \
|
||||
__m128i t0 = _mm_alignr_epi8(B1, B0, 8); \
|
||||
__m128i t1 = _mm_alignr_epi8(B0, B1, 8); \
|
||||
B0 = t0; \
|
||||
B1 = t1; \
|
||||
\
|
||||
t0 = C0; \
|
||||
C0 = C1; \
|
||||
C1 = t0; \
|
||||
\
|
||||
t0 = _mm_alignr_epi8(D1, D0, 8); \
|
||||
t1 = _mm_alignr_epi8(D0, D1, 8); \
|
||||
D0 = t1; \
|
||||
D1 = t0; \
|
||||
} while ((void)0, 0) |
||||
|
||||
#define UNDIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1) \ |
||||
do { \
|
||||
__m128i t0 = _mm_alignr_epi8(B0, B1, 8); \
|
||||
__m128i t1 = _mm_alignr_epi8(B1, B0, 8); \
|
||||
B0 = t0; \
|
||||
B1 = t1; \
|
||||
\
|
||||
t0 = C0; \
|
||||
C0 = C1; \
|
||||
C1 = t0; \
|
||||
\
|
||||
t0 = _mm_alignr_epi8(D0, D1, 8); \
|
||||
t1 = _mm_alignr_epi8(D1, D0, 8); \
|
||||
D0 = t1; \
|
||||
D1 = t0; \
|
||||
} while ((void)0, 0) |
||||
#else /* SSE2 */ |
||||
#define DIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1) \ |
||||
do { \
|
||||
__m128i t0 = D0; \
|
||||
__m128i t1 = B0; \
|
||||
D0 = C0; \
|
||||
C0 = C1; \
|
||||
C1 = D0; \
|
||||
D0 = _mm_unpackhi_epi64(D1, _mm_unpacklo_epi64(t0, t0)); \
|
||||
D1 = _mm_unpackhi_epi64(t0, _mm_unpacklo_epi64(D1, D1)); \
|
||||
B0 = _mm_unpackhi_epi64(B0, _mm_unpacklo_epi64(B1, B1)); \
|
||||
B1 = _mm_unpackhi_epi64(B1, _mm_unpacklo_epi64(t1, t1)); \
|
||||
} while ((void)0, 0) |
||||
|
||||
#define UNDIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1) \ |
||||
do { \
|
||||
__m128i t0, t1; \
|
||||
t0 = C0; \
|
||||
C0 = C1; \
|
||||
C1 = t0; \
|
||||
t0 = B0; \
|
||||
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)); \
|
||||
D1 = _mm_unpackhi_epi64(D1, _mm_unpacklo_epi64(t1, t1)); \
|
||||
} while ((void)0, 0) |
||||
#endif |
||||
|
||||
#define BLAKE2_ROUND(A0, A1, B0, B1, C0, C1, D0, D1) \ |
||||
do { \
|
||||
G1(A0, B0, C0, D0, A1, B1, C1, D1); \
|
||||
G2(A0, B0, C0, D0, A1, B1, C1, D1); \
|
||||
\
|
||||
DIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1); \
|
||||
\
|
||||
G1(A0, B0, C0, D0, A1, B1, C1, D1); \
|
||||
G2(A0, B0, C0, D0, A1, B1, C1, D1); \
|
||||
\
|
||||
UNDIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1); \
|
||||
} while ((void)0, 0) |
||||
#else /* __AVX2__ */ |
||||
|
||||
#include <immintrin.h> |
||||
|
||||
#define rotr32(x) _mm256_shuffle_epi32(x, _MM_SHUFFLE(2, 3, 0, 1)) |
||||
#define rotr24(x) _mm256_shuffle_epi8(x, _mm256_setr_epi8(3, 4, 5, 6, 7, 0, 1, 2, 11, 12, 13, 14, 15, 8, 9, 10, 3, 4, 5, 6, 7, 0, 1, 2, 11, 12, 13, 14, 15, 8, 9, 10)) |
||||
#define rotr16(x) _mm256_shuffle_epi8(x, _mm256_setr_epi8(2, 3, 4, 5, 6, 7, 0, 1, 10, 11, 12, 13, 14, 15, 8, 9, 2, 3, 4, 5, 6, 7, 0, 1, 10, 11, 12, 13, 14, 15, 8, 9)) |
||||
#define rotr63(x) _mm256_xor_si256(_mm256_srli_epi64((x), 63), _mm256_add_epi64((x), (x))) |
||||
|
||||
#define G1_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \ |
||||
do { \
|
||||
__m256i ml = _mm256_mul_epu32(A0, B0); \
|
||||
ml = _mm256_add_epi64(ml, ml); \
|
||||
A0 = _mm256_add_epi64(A0, _mm256_add_epi64(B0, ml)); \
|
||||
D0 = _mm256_xor_si256(D0, A0); \
|
||||
D0 = rotr32(D0); \
|
||||
\
|
||||
ml = _mm256_mul_epu32(C0, D0); \
|
||||
ml = _mm256_add_epi64(ml, ml); \
|
||||
C0 = _mm256_add_epi64(C0, _mm256_add_epi64(D0, ml)); \
|
||||
\
|
||||
B0 = _mm256_xor_si256(B0, C0); \
|
||||
B0 = rotr24(B0); \
|
||||
\
|
||||
ml = _mm256_mul_epu32(A1, B1); \
|
||||
ml = _mm256_add_epi64(ml, ml); \
|
||||
A1 = _mm256_add_epi64(A1, _mm256_add_epi64(B1, ml)); \
|
||||
D1 = _mm256_xor_si256(D1, A1); \
|
||||
D1 = rotr32(D1); \
|
||||
\
|
||||
ml = _mm256_mul_epu32(C1, D1); \
|
||||
ml = _mm256_add_epi64(ml, ml); \
|
||||
C1 = _mm256_add_epi64(C1, _mm256_add_epi64(D1, ml)); \
|
||||
\
|
||||
B1 = _mm256_xor_si256(B1, C1); \
|
||||
B1 = rotr24(B1); \
|
||||
} while((void)0, 0); |
||||
|
||||
#define G2_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \ |
||||
do { \
|
||||
__m256i ml = _mm256_mul_epu32(A0, B0); \
|
||||
ml = _mm256_add_epi64(ml, ml); \
|
||||
A0 = _mm256_add_epi64(A0, _mm256_add_epi64(B0, ml)); \
|
||||
D0 = _mm256_xor_si256(D0, A0); \
|
||||
D0 = rotr16(D0); \
|
||||
\
|
||||
ml = _mm256_mul_epu32(C0, D0); \
|
||||
ml = _mm256_add_epi64(ml, ml); \
|
||||
C0 = _mm256_add_epi64(C0, _mm256_add_epi64(D0, ml)); \
|
||||
B0 = _mm256_xor_si256(B0, C0); \
|
||||
B0 = rotr63(B0); \
|
||||
\
|
||||
ml = _mm256_mul_epu32(A1, B1); \
|
||||
ml = _mm256_add_epi64(ml, ml); \
|
||||
A1 = _mm256_add_epi64(A1, _mm256_add_epi64(B1, ml)); \
|
||||
D1 = _mm256_xor_si256(D1, A1); \
|
||||
D1 = rotr16(D1); \
|
||||
\
|
||||
ml = _mm256_mul_epu32(C1, D1); \
|
||||
ml = _mm256_add_epi64(ml, ml); \
|
||||
C1 = _mm256_add_epi64(C1, _mm256_add_epi64(D1, ml)); \
|
||||
B1 = _mm256_xor_si256(B1, C1); \
|
||||
B1 = rotr63(B1); \
|
||||
} while((void)0, 0); |
||||
|
||||
#define DIAGONALIZE_1(A0, B0, C0, D0, A1, B1, C1, D1) \ |
||||
do { \
|
||||
B0 = _mm256_permute4x64_epi64(B0, _MM_SHUFFLE(0, 3, 2, 1)); \
|
||||
C0 = _mm256_permute4x64_epi64(C0, _MM_SHUFFLE(1, 0, 3, 2)); \
|
||||
D0 = _mm256_permute4x64_epi64(D0, _MM_SHUFFLE(2, 1, 0, 3)); \
|
||||
\
|
||||
B1 = _mm256_permute4x64_epi64(B1, _MM_SHUFFLE(0, 3, 2, 1)); \
|
||||
C1 = _mm256_permute4x64_epi64(C1, _MM_SHUFFLE(1, 0, 3, 2)); \
|
||||
D1 = _mm256_permute4x64_epi64(D1, _MM_SHUFFLE(2, 1, 0, 3)); \
|
||||
} while((void)0, 0); |
||||
|
||||
#define DIAGONALIZE_2(A0, A1, B0, B1, C0, C1, D0, D1) \ |
||||
do { \
|
||||
__m256i tmp1 = _mm256_blend_epi32(B0, B1, 0xCC); \
|
||||
__m256i tmp2 = _mm256_blend_epi32(B0, B1, 0x33); \
|
||||
B1 = _mm256_permute4x64_epi64(tmp1, _MM_SHUFFLE(2,3,0,1)); \
|
||||
B0 = _mm256_permute4x64_epi64(tmp2, _MM_SHUFFLE(2,3,0,1)); \
|
||||
\
|
||||
tmp1 = C0; \
|
||||
C0 = C1; \
|
||||
C1 = tmp1; \
|
||||
\
|
||||
tmp1 = _mm256_blend_epi32(D0, D1, 0xCC); \
|
||||
tmp2 = _mm256_blend_epi32(D0, D1, 0x33); \
|
||||
D0 = _mm256_permute4x64_epi64(tmp1, _MM_SHUFFLE(2,3,0,1)); \
|
||||
D1 = _mm256_permute4x64_epi64(tmp2, _MM_SHUFFLE(2,3,0,1)); \
|
||||
} while(0); |
||||
|
||||
#define UNDIAGONALIZE_1(A0, B0, C0, D0, A1, B1, C1, D1) \ |
||||
do { \
|
||||
B0 = _mm256_permute4x64_epi64(B0, _MM_SHUFFLE(2, 1, 0, 3)); \
|
||||
C0 = _mm256_permute4x64_epi64(C0, _MM_SHUFFLE(1, 0, 3, 2)); \
|
||||
D0 = _mm256_permute4x64_epi64(D0, _MM_SHUFFLE(0, 3, 2, 1)); \
|
||||
\
|
||||
B1 = _mm256_permute4x64_epi64(B1, _MM_SHUFFLE(2, 1, 0, 3)); \
|
||||
C1 = _mm256_permute4x64_epi64(C1, _MM_SHUFFLE(1, 0, 3, 2)); \
|
||||
D1 = _mm256_permute4x64_epi64(D1, _MM_SHUFFLE(0, 3, 2, 1)); \
|
||||
} while((void)0, 0); |
||||
|
||||
#define UNDIAGONALIZE_2(A0, A1, B0, B1, C0, C1, D0, D1) \ |
||||
do { \
|
||||
__m256i tmp1 = _mm256_blend_epi32(B0, B1, 0xCC); \
|
||||
__m256i tmp2 = _mm256_blend_epi32(B0, B1, 0x33); \
|
||||
B0 = _mm256_permute4x64_epi64(tmp1, _MM_SHUFFLE(2,3,0,1)); \
|
||||
B1 = _mm256_permute4x64_epi64(tmp2, _MM_SHUFFLE(2,3,0,1)); \
|
||||
\
|
||||
tmp1 = C0; \
|
||||
C0 = C1; \
|
||||
C1 = tmp1; \
|
||||
\
|
||||
tmp1 = _mm256_blend_epi32(D0, D1, 0x33); \
|
||||
tmp2 = _mm256_blend_epi32(D0, D1, 0xCC); \
|
||||
D0 = _mm256_permute4x64_epi64(tmp1, _MM_SHUFFLE(2,3,0,1)); \
|
||||
D1 = _mm256_permute4x64_epi64(tmp2, _MM_SHUFFLE(2,3,0,1)); \
|
||||
} while((void)0, 0); |
||||
|
||||
#define BLAKE2_ROUND_1(A0, A1, B0, B1, C0, C1, D0, D1) \ |
||||
do{ \
|
||||
G1_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
|
||||
G2_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
|
||||
\
|
||||
DIAGONALIZE_1(A0, B0, C0, D0, A1, B1, C1, D1) \
|
||||
\
|
||||
G1_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
|
||||
G2_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
|
||||
\
|
||||
UNDIAGONALIZE_1(A0, B0, C0, D0, A1, B1, C1, D1) \
|
||||
} while((void)0, 0); |
||||
|
||||
#define BLAKE2_ROUND_2(A0, A1, B0, B1, C0, C1, D0, D1) \ |
||||
do{ \
|
||||
G1_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
|
||||
G2_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
|
||||
\
|
||||
DIAGONALIZE_2(A0, A1, B0, B1, C0, C1, D0, D1) \
|
||||
\
|
||||
G1_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
|
||||
G2_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
|
||||
\
|
||||
UNDIAGONALIZE_2(A0, A1, B0, B1, C0, C1, D0, D1) \
|
||||
} while((void)0, 0); |
||||
|
||||
#endif /* __AVX2__ */ |
||||
|
||||
#else /* __AVX512F__ */ |
||||
|
||||
#include <immintrin.h> |
||||
|
||||
#define ror64(x, n) _mm512_ror_epi64((x), (n)) |
||||
|
||||
static __m512i muladd(__m512i x, __m512i y) |
||||
{ |
||||
__m512i z = _mm512_mul_epu32(x, y); |
||||
return _mm512_add_epi64(_mm512_add_epi64(x, y), _mm512_add_epi64(z, z)); |
||||
} |
||||
|
||||
#define G1(A0, B0, C0, D0, A1, B1, C1, D1) \ |
||||
do { \
|
||||
A0 = muladd(A0, B0); \
|
||||
A1 = muladd(A1, B1); \
|
||||
\
|
||||
D0 = _mm512_xor_si512(D0, A0); \
|
||||
D1 = _mm512_xor_si512(D1, A1); \
|
||||
\
|
||||
D0 = ror64(D0, 32); \
|
||||
D1 = ror64(D1, 32); \
|
||||
\
|
||||
C0 = muladd(C0, D0); \
|
||||
C1 = muladd(C1, D1); \
|
||||
\
|
||||
B0 = _mm512_xor_si512(B0, C0); \
|
||||
B1 = _mm512_xor_si512(B1, C1); \
|
||||
\
|
||||
B0 = ror64(B0, 24); \
|
||||
B1 = ror64(B1, 24); \
|
||||
} while ((void)0, 0) |
||||
|
||||
#define G2(A0, B0, C0, D0, A1, B1, C1, D1) \ |
||||
do { \
|
||||
A0 = muladd(A0, B0); \
|
||||
A1 = muladd(A1, B1); \
|
||||
\
|
||||
D0 = _mm512_xor_si512(D0, A0); \
|
||||
D1 = _mm512_xor_si512(D1, A1); \
|
||||
\
|
||||
D0 = ror64(D0, 16); \
|
||||
D1 = ror64(D1, 16); \
|
||||
\
|
||||
C0 = muladd(C0, D0); \
|
||||
C1 = muladd(C1, D1); \
|
||||
\
|
||||
B0 = _mm512_xor_si512(B0, C0); \
|
||||
B1 = _mm512_xor_si512(B1, C1); \
|
||||
\
|
||||
B0 = ror64(B0, 63); \
|
||||
B1 = ror64(B1, 63); \
|
||||
} while ((void)0, 0) |
||||
|
||||
#define DIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1) \ |
||||
do { \
|
||||
B0 = _mm512_permutex_epi64(B0, _MM_SHUFFLE(0, 3, 2, 1)); \
|
||||
B1 = _mm512_permutex_epi64(B1, _MM_SHUFFLE(0, 3, 2, 1)); \
|
||||
\
|
||||
C0 = _mm512_permutex_epi64(C0, _MM_SHUFFLE(1, 0, 3, 2)); \
|
||||
C1 = _mm512_permutex_epi64(C1, _MM_SHUFFLE(1, 0, 3, 2)); \
|
||||
\
|
||||
D0 = _mm512_permutex_epi64(D0, _MM_SHUFFLE(2, 1, 0, 3)); \
|
||||
D1 = _mm512_permutex_epi64(D1, _MM_SHUFFLE(2, 1, 0, 3)); \
|
||||
} while ((void)0, 0) |
||||
|
||||
#define UNDIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1) \ |
||||
do { \
|
||||
B0 = _mm512_permutex_epi64(B0, _MM_SHUFFLE(2, 1, 0, 3)); \
|
||||
B1 = _mm512_permutex_epi64(B1, _MM_SHUFFLE(2, 1, 0, 3)); \
|
||||
\
|
||||
C0 = _mm512_permutex_epi64(C0, _MM_SHUFFLE(1, 0, 3, 2)); \
|
||||
C1 = _mm512_permutex_epi64(C1, _MM_SHUFFLE(1, 0, 3, 2)); \
|
||||
\
|
||||
D0 = _mm512_permutex_epi64(D0, _MM_SHUFFLE(0, 3, 2, 1)); \
|
||||
D1 = _mm512_permutex_epi64(D1, _MM_SHUFFLE(0, 3, 2, 1)); \
|
||||
} while ((void)0, 0) |
||||
|
||||
#define BLAKE2_ROUND(A0, B0, C0, D0, A1, B1, C1, D1) \ |
||||
do { \
|
||||
G1(A0, B0, C0, D0, A1, B1, C1, D1); \
|
||||
G2(A0, B0, C0, D0, A1, B1, C1, D1); \
|
||||
\
|
||||
DIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1); \
|
||||
\
|
||||
G1(A0, B0, C0, D0, A1, B1, C1, D1); \
|
||||
G2(A0, B0, C0, D0, A1, B1, C1, D1); \
|
||||
\
|
||||
UNDIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1); \
|
||||
} while ((void)0, 0) |
||||
|
||||
#define SWAP_HALVES(A0, A1) \ |
||||
do { \
|
||||
__m512i t0, t1; \
|
||||
t0 = _mm512_shuffle_i64x2(A0, A1, _MM_SHUFFLE(1, 0, 1, 0)); \
|
||||
t1 = _mm512_shuffle_i64x2(A0, A1, _MM_SHUFFLE(3, 2, 3, 2)); \
|
||||
A0 = t0; \
|
||||
A1 = t1; \
|
||||
} while((void)0, 0) |
||||
|
||||
#define SWAP_QUARTERS(A0, A1) \ |
||||
do { \
|
||||
SWAP_HALVES(A0, A1); \
|
||||
A0 = _mm512_permutexvar_epi64(_mm512_setr_epi64(0, 1, 4, 5, 2, 3, 6, 7), A0); \
|
||||
A1 = _mm512_permutexvar_epi64(_mm512_setr_epi64(0, 1, 4, 5, 2, 3, 6, 7), A1); \
|
||||
} while((void)0, 0) |
||||
|
||||
#define UNSWAP_QUARTERS(A0, A1) \ |
||||
do { \
|
||||
A0 = _mm512_permutexvar_epi64(_mm512_setr_epi64(0, 1, 4, 5, 2, 3, 6, 7), A0); \
|
||||
A1 = _mm512_permutexvar_epi64(_mm512_setr_epi64(0, 1, 4, 5, 2, 3, 6, 7), A1); \
|
||||
SWAP_HALVES(A0, A1); \
|
||||
} while((void)0, 0) |
||||
|
||||
#define BLAKE2_ROUND_1(A0, C0, B0, D0, A1, C1, B1, D1) \ |
||||
do { \
|
||||
SWAP_HALVES(A0, B0); \
|
||||
SWAP_HALVES(C0, D0); \
|
||||
SWAP_HALVES(A1, B1); \
|
||||
SWAP_HALVES(C1, D1); \
|
||||
BLAKE2_ROUND(A0, B0, C0, D0, A1, B1, C1, D1); \
|
||||
SWAP_HALVES(A0, B0); \
|
||||
SWAP_HALVES(C0, D0); \
|
||||
SWAP_HALVES(A1, B1); \
|
||||
SWAP_HALVES(C1, D1); \
|
||||
} while ((void)0, 0) |
||||
|
||||
#define BLAKE2_ROUND_2(A0, A1, B0, B1, C0, C1, D0, D1) \ |
||||
do { \
|
||||
SWAP_QUARTERS(A0, A1); \
|
||||
SWAP_QUARTERS(B0, B1); \
|
||||
SWAP_QUARTERS(C0, C1); \
|
||||
SWAP_QUARTERS(D0, D1); \
|
||||
BLAKE2_ROUND(A0, B0, C0, D0, A1, B1, C1, D1); \
|
||||
UNSWAP_QUARTERS(A0, A1); \
|
||||
UNSWAP_QUARTERS(B0, B1); \
|
||||
UNSWAP_QUARTERS(C0, C1); \
|
||||
UNSWAP_QUARTERS(D0, D1); \
|
||||
} while ((void)0, 0) |
||||
|
||||
#endif /* __AVX512F__ */ |
||||
#endif /* BLAKE_ROUND_MKA_OPT_H */ |
||||
@ -0,0 +1,56 @@
|
||||
/*
|
||||
* 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 : http://creativecommons.org/publicdomain/zero/1.0
|
||||
* - Apache 2.0 : http://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. |
||||
*/ |
||||
|
||||
#ifndef BLAKE_ROUND_MKA_H |
||||
#define BLAKE_ROUND_MKA_H |
||||
|
||||
#include "blake2.h" |
||||
#include "blake2-impl.h" |
||||
|
||||
/* designed by the Lyra PHC team */ |
||||
static BLAKE2_INLINE uint64_t fBlaMka(uint64_t x, uint64_t y) { |
||||
const uint64_t m = UINT64_C(0xFFFFFFFF); |
||||
const uint64_t xy = (x & m) * (y & m); |
||||
return x + y + 2 * xy; |
||||
} |
||||
|
||||
#define G(a, b, c, d) \ |
||||
do { \
|
||||
a = fBlaMka(a, b); \
|
||||
d = rotr64(d ^ a, 32); \
|
||||
c = fBlaMka(c, d); \
|
||||
b = rotr64(b ^ c, 24); \
|
||||
a = fBlaMka(a, b); \
|
||||
d = rotr64(d ^ a, 16); \
|
||||
c = fBlaMka(c, d); \
|
||||
b = rotr64(b ^ c, 63); \
|
||||
} while ((void)0, 0) |
||||
|
||||
#define BLAKE2_ROUND_NOMSG(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, \ |
||||
v12, v13, v14, v15) \
|
||||
do { \
|
||||
G(v0, v4, v8, v12); \
|
||||
G(v1, v5, v9, v13); \
|
||||
G(v2, v6, v10, v14); \
|
||||
G(v3, v7, v11, v15); \
|
||||
G(v0, v5, v10, v15); \
|
||||
G(v1, v6, v11, v12); \
|
||||
G(v2, v7, v8, v13); \
|
||||
G(v3, v4, v9, v14); \
|
||||
} while ((void)0, 0) |
||||
|
||||
#endif |
||||
@ -0,0 +1,648 @@
|
||||
/*
|
||||
* 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 : http://creativecommons.org/publicdomain/zero/1.0
|
||||
* - Apache 2.0 : http://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. |
||||
*/ |
||||
|
||||
/*For memory wiping*/ |
||||
#ifdef _MSC_VER |
||||
#include <windows.h> |
||||
#include <winbase.h> /* For SecureZeroMemory */ |
||||
#endif |
||||
#if defined __STDC_LIB_EXT1__ |
||||
#define __STDC_WANT_LIB_EXT1__ 1 |
||||
#endif |
||||
#define VC_GE_2005(version) (version >= 1400) |
||||
|
||||
/* for explicit_bzero() on glibc */ |
||||
#define _DEFAULT_SOURCE |
||||
|
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
|
||||
#include "core.h" |
||||
#include "thread.h" |
||||
#include "blake2/blake2.h" |
||||
#include "blake2/blake2-impl.h" |
||||
|
||||
#ifdef GENKAT |
||||
#include "genkat.h" |
||||
#endif |
||||
|
||||
#if defined(__clang__) |
||||
#if __has_attribute(optnone) |
||||
#define NOT_OPTIMIZED __attribute__((optnone)) |
||||
#endif |
||||
#elif defined(__GNUC__) |
||||
#define GCC_VERSION \ |
||||
(__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) |
||||
#if GCC_VERSION >= 40400 |
||||
#define NOT_OPTIMIZED __attribute__((optimize("O0"))) |
||||
#endif |
||||
#endif |
||||
#ifndef NOT_OPTIMIZED |
||||
#define NOT_OPTIMIZED |
||||
#endif |
||||
|
||||
/***************Instance and Position constructors**********/ |
||||
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_QWORDS_IN_BLOCK); |
||||
} |
||||
|
||||
void xor_block(block *dst, const block *src) { |
||||
int 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_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_QWORDS_IN_BLOCK; ++i) { |
||||
store64((uint8_t *)output + i * sizeof(src->v[i]), src->v[i]); |
||||
} |
||||
} |
||||
|
||||
/***************Memory functions*****************/ |
||||
|
||||
int allocate_memory(const argon2_context *context, uint8_t **memory, |
||||
size_t num, size_t size) { |
||||
size_t memory_size = num*size; |
||||
if (memory == NULL) { |
||||
return ARGON2_MEMORY_ALLOCATION_ERROR; |
||||
} |
||||
|
||||
/* 1. Check for multiplication overflow */ |
||||
if (size != 0 && memory_size / size != num) { |
||||
return ARGON2_MEMORY_ALLOCATION_ERROR; |
||||
} |
||||
|
||||
/* 2. Try to allocate with appropriate allocator */ |
||||
if (context->allocate_cbk) { |
||||
(context->allocate_cbk)(memory, memory_size); |
||||
} else { |
||||
*memory = malloc(memory_size); |
||||
} |
||||
|
||||
if (*memory == NULL) { |
||||
return ARGON2_MEMORY_ALLOCATION_ERROR; |
||||
} |
||||
|
||||
return ARGON2_OK; |
||||
} |
||||
|
||||
void free_memory(const argon2_context *context, uint8_t *memory, |
||||
size_t num, size_t size) { |
||||
size_t memory_size = num*size; |
||||
clear_internal_memory(memory, memory_size); |
||||
if (context->free_cbk) { |
||||
(context->free_cbk)(memory, memory_size); |
||||
} else { |
||||
free(memory); |
||||
} |
||||
} |
||||
|
||||
#if defined(__OpenBSD__) |
||||
#define HAVE_EXPLICIT_BZERO 1 |
||||
#elif defined(__GLIBC__) && defined(__GLIBC_PREREQ) |
||||
#if __GLIBC_PREREQ(2,25) |
||||
#define HAVE_EXPLICIT_BZERO 1 |
||||
#endif |
||||
#endif |
||||
|
||||
void NOT_OPTIMIZED secure_wipe_memory(void *v, size_t n) { |
||||
#if defined(_MSC_VER) && VC_GE_2005(_MSC_VER) |
||||
SecureZeroMemory(v, n); |
||||
#elif defined memset_s |
||||
memset_s(v, n, 0, n); |
||||
#elif defined(HAVE_EXPLICIT_BZERO) |
||||
explicit_bzero(v, n); |
||||
#else |
||||
static void *(*const volatile memset_sec)(void *, int, size_t) = &memset; |
||||
memset_sec(v, 0, n); |
||||
#endif |
||||
} |
||||
|
||||
/* Memory clear flag defaults to true. */ |
||||
int FLAG_clear_internal_memory = 1; |
||||
void clear_internal_memory(void *v, size_t n) { |
||||
if (FLAG_clear_internal_memory && v) { |
||||
secure_wipe_memory(v, n); |
||||
} |
||||
} |
||||
|
||||
void finalize(const argon2_context *context, argon2_instance_t *instance) { |
||||
if (context != NULL && instance != NULL) { |
||||
block blockhash; |
||||
uint32_t l; |
||||
|
||||
copy_block(&blockhash, instance->memory + instance->lane_length - 1); |
||||
|
||||
/* XOR the last blocks */ |
||||
for (l = 1; l < instance->lanes; ++l) { |
||||
uint32_t last_block_in_lane = |
||||
l * instance->lane_length + (instance->lane_length - 1); |
||||
xor_block(&blockhash, instance->memory + last_block_in_lane); |
||||
} |
||||
|
||||
/* Hash the result */ |
||||
{ |
||||
uint8_t blockhash_bytes[ARGON2_BLOCK_SIZE]; |
||||
store_block(blockhash_bytes, &blockhash); |
||||
blake2b_long(context->out, context->outlen, blockhash_bytes, |
||||
ARGON2_BLOCK_SIZE); |
||||
/* clear blockhash and blockhash_bytes */ |
||||
clear_internal_memory(blockhash.v, ARGON2_BLOCK_SIZE); |
||||
clear_internal_memory(blockhash_bytes, ARGON2_BLOCK_SIZE); |
||||
} |
||||
|
||||
#ifdef GENKAT |
||||
print_tag(context->out, context->outlen); |
||||
#endif |
||||
|
||||
free_memory(context, (uint8_t *)instance->memory, |
||||
instance->memory_blocks, sizeof(block)); |
||||
} |
||||
} |
||||
|
||||
uint32_t index_alpha(const argon2_instance_t *instance, |
||||
const argon2_position_t *position, uint32_t pseudo_rand, |
||||
int same_lane) { |
||||
/*
|
||||
* Pass 0: |
||||
* This lane : all already finished segments plus already constructed |
||||
* blocks in this segment |
||||
* Other lanes : all already finished segments |
||||
* Pass 1+: |
||||
* This lane : (SYNC_POINTS - 1) last segments plus already constructed |
||||
* blocks in this segment |
||||
* Other lanes : (SYNC_POINTS - 1) last segments |
||||
*/ |
||||
uint32_t reference_area_size; |
||||
uint64_t relative_position; |
||||
uint32_t start_position, absolute_position; |
||||
|
||||
if (0 == position->pass) { |
||||
/* First pass */ |
||||
if (0 == position->slice) { |
||||
/* First slice */ |
||||
reference_area_size = |
||||
position->index - 1; /* all but the previous */ |
||||
} else { |
||||
if (same_lane) { |
||||
/* The same lane => add current segment */ |
||||
reference_area_size = |
||||
position->slice * instance->segment_length + |
||||
position->index - 1; |
||||
} else { |
||||
reference_area_size = |
||||
position->slice * instance->segment_length + |
||||
((position->index == 0) ? (-1) : 0); |
||||
} |
||||
} |
||||
} else { |
||||
/* Second pass */ |
||||
if (same_lane) { |
||||
reference_area_size = instance->lane_length - |
||||
instance->segment_length + position->index - |
||||
1; |
||||
} else { |
||||
reference_area_size = instance->lane_length - |
||||
instance->segment_length + |
||||
((position->index == 0) ? (-1) : 0); |
||||
} |
||||
} |
||||
|
||||
/* 1.2.4. Mapping pseudo_rand to 0..<reference_area_size-1> and produce
|
||||
* relative position */ |
||||
relative_position = pseudo_rand; |
||||
relative_position = relative_position * relative_position >> 32; |
||||
relative_position = reference_area_size - 1 - |
||||
(reference_area_size * relative_position >> 32); |
||||
|
||||
/* 1.2.5 Computing starting position */ |
||||
start_position = 0; |
||||
|
||||
if (0 != position->pass) { |
||||
start_position = (position->slice == ARGON2_SYNC_POINTS - 1) |
||||
? 0 |
||||
: (position->slice + 1) * instance->segment_length; |
||||
} |
||||
|
||||
/* 1.2.6. Computing absolute position */ |
||||
absolute_position = (start_position + relative_position) % |
||||
instance->lane_length; /* absolute position */ |
||||
return absolute_position; |
||||
} |
||||
|
||||
/* Single-threaded version for p=1 case */ |
||||
static int fill_memory_blocks_st(argon2_instance_t *instance) { |
||||
uint32_t r, s, l; |
||||
|
||||
for (r = 0; r < instance->passes; ++r) { |
||||
for (s = 0; s < ARGON2_SYNC_POINTS; ++s) { |
||||
for (l = 0; l < instance->lanes; ++l) { |
||||
argon2_position_t position = {r, l, (uint8_t)s, 0}; |
||||
fill_segment(instance, position); |
||||
} |
||||
} |
||||
#ifdef GENKAT |
||||
internal_kat(instance, r); /* Print all memory blocks */ |
||||
#endif |
||||
} |
||||
return ARGON2_OK; |
||||
} |
||||
|
||||
#if !defined(ARGON2_NO_THREADS) |
||||
|
||||
#ifdef _WIN32 |
||||
static unsigned __stdcall fill_segment_thr(void *thread_data) |
||||
#else |
||||
static void *fill_segment_thr(void *thread_data) |
||||
#endif |
||||
{ |
||||
argon2_thread_data *my_data = thread_data; |
||||
fill_segment(my_data->instance_ptr, my_data->pos); |
||||
argon2_thread_exit(); |
||||
return 0; |
||||
} |
||||
|
||||
/* Multi-threaded version for p > 1 case */ |
||||
static int fill_memory_blocks_mt(argon2_instance_t *instance) { |
||||
uint32_t r, s; |
||||
argon2_thread_handle_t *thread = NULL; |
||||
argon2_thread_data *thr_data = NULL; |
||||
int rc = ARGON2_OK; |
||||
|
||||
/* 1. Allocating space for threads */ |
||||
thread = calloc(instance->lanes, sizeof(argon2_thread_handle_t)); |
||||
if (thread == NULL) { |
||||
rc = ARGON2_MEMORY_ALLOCATION_ERROR; |
||||
goto fail; |
||||
} |
||||
|
||||
thr_data = calloc(instance->lanes, sizeof(argon2_thread_data)); |
||||
if (thr_data == NULL) { |
||||
rc = ARGON2_MEMORY_ALLOCATION_ERROR; |
||||
goto fail; |
||||
} |
||||
|
||||
for (r = 0; r < instance->passes; ++r) { |
||||
for (s = 0; s < ARGON2_SYNC_POINTS; ++s) { |
||||
uint32_t l, ll; |
||||
|
||||
/* 2. Calling threads */ |
||||
for (l = 0; l < instance->lanes; ++l) { |
||||
argon2_position_t position; |
||||
|
||||
/* 2.1 Join a thread if limit is exceeded */ |
||||
if (l >= instance->threads) { |
||||
if (argon2_thread_join(thread[l - instance->threads])) { |
||||
rc = ARGON2_THREAD_FAIL; |
||||
goto fail; |
||||
} |
||||
} |
||||
|
||||
/* 2.2 Create thread */ |
||||
position.pass = r; |
||||
position.lane = l; |
||||
position.slice = (uint8_t)s; |
||||
position.index = 0; |
||||
thr_data[l].instance_ptr = |
||||
instance; /* preparing the thread input */ |
||||
memcpy(&(thr_data[l].pos), &position, |
||||
sizeof(argon2_position_t)); |
||||
if (argon2_thread_create(&thread[l], &fill_segment_thr, |
||||
(void *)&thr_data[l])) { |
||||
/* Wait for already running threads */ |
||||
for (ll = 0; ll < l; ++ll) |
||||
argon2_thread_join(thread[ll]); |
||||
rc = ARGON2_THREAD_FAIL; |
||||
goto fail; |
||||
} |
||||
|
||||
/* fill_segment(instance, position); */ |
||||
/*Non-thread equivalent of the lines above */ |
||||
} |
||||
|
||||
/* 3. Joining remaining threads */ |
||||
for (l = instance->lanes - instance->threads; l < instance->lanes; |
||||
++l) { |
||||
if (argon2_thread_join(thread[l])) { |
||||
rc = ARGON2_THREAD_FAIL; |
||||
goto fail; |
||||
} |
||||
} |
||||
} |
||||
|
||||
#ifdef GENKAT |
||||
internal_kat(instance, r); /* Print all memory blocks */ |
||||
#endif |
||||
} |
||||
|
||||
fail: |
||||
if (thread != NULL) { |
||||
free(thread); |
||||
} |
||||
if (thr_data != NULL) { |
||||
free(thr_data); |
||||
} |
||||
return rc; |
||||
} |
||||
|
||||
#endif /* ARGON2_NO_THREADS */ |
||||
|
||||
int fill_memory_blocks(argon2_instance_t *instance) { |
||||
if (instance == NULL || instance->lanes == 0) { |
||||
return ARGON2_INCORRECT_PARAMETER; |
||||
} |
||||
#if defined(ARGON2_NO_THREADS) |
||||
return fill_memory_blocks_st(instance); |
||||
#else |
||||
return instance->threads == 1 ? |
||||
fill_memory_blocks_st(instance) : fill_memory_blocks_mt(instance); |
||||
#endif |
||||
} |
||||
|
||||
int validate_inputs(const argon2_context *context) { |
||||
if (NULL == context) { |
||||
return ARGON2_INCORRECT_PARAMETER; |
||||
} |
||||
|
||||
if (NULL == context->out) { |
||||
return ARGON2_OUTPUT_PTR_NULL; |
||||
} |
||||
|
||||
/* Validate output length */ |
||||
if (ARGON2_MIN_OUTLEN > context->outlen) { |
||||
return ARGON2_OUTPUT_TOO_SHORT; |
||||
} |
||||
|
||||
if (ARGON2_MAX_OUTLEN < context->outlen) { |
||||
return ARGON2_OUTPUT_TOO_LONG; |
||||
} |
||||
|
||||
/* Validate password (required param) */ |
||||
if (NULL == context->pwd) { |
||||
if (0 != context->pwdlen) { |
||||
return ARGON2_PWD_PTR_MISMATCH; |
||||
} |
||||
} |
||||
|
||||
if (ARGON2_MIN_PWD_LENGTH > context->pwdlen) { |
||||
return ARGON2_PWD_TOO_SHORT; |
||||
} |
||||
|
||||
if (ARGON2_MAX_PWD_LENGTH < context->pwdlen) { |
||||
return ARGON2_PWD_TOO_LONG; |
||||
} |
||||
|
||||
/* Validate salt (required param) */ |
||||
if (NULL == context->salt) { |
||||
if (0 != context->saltlen) { |
||||
return ARGON2_SALT_PTR_MISMATCH; |
||||
} |
||||
} |
||||
|
||||
if (ARGON2_MIN_SALT_LENGTH > context->saltlen) { |
||||
return ARGON2_SALT_TOO_SHORT; |
||||
} |
||||
|
||||
if (ARGON2_MAX_SALT_LENGTH < context->saltlen) { |
||||
return ARGON2_SALT_TOO_LONG; |
||||
} |
||||
|
||||
/* Validate secret (optional param) */ |
||||
if (NULL == context->secret) { |
||||
if (0 != context->secretlen) { |
||||
return ARGON2_SECRET_PTR_MISMATCH; |
||||
} |
||||
} else { |
||||
if (ARGON2_MIN_SECRET > context->secretlen) { |
||||
return ARGON2_SECRET_TOO_SHORT; |
||||
} |
||||
if (ARGON2_MAX_SECRET < context->secretlen) { |
||||
return ARGON2_SECRET_TOO_LONG; |
||||
} |
||||
} |
||||
|
||||
/* Validate associated data (optional param) */ |
||||
if (NULL == context->ad) { |
||||
if (0 != context->adlen) { |
||||
return ARGON2_AD_PTR_MISMATCH; |
||||
} |
||||
} else { |
||||
if (ARGON2_MIN_AD_LENGTH > context->adlen) { |
||||
return ARGON2_AD_TOO_SHORT; |
||||
} |
||||
if (ARGON2_MAX_AD_LENGTH < context->adlen) { |
||||
return ARGON2_AD_TOO_LONG; |
||||
} |
||||
} |
||||
|
||||
/* Validate memory cost */ |
||||
if (ARGON2_MIN_MEMORY > context->m_cost) { |
||||
return ARGON2_MEMORY_TOO_LITTLE; |
||||
} |
||||
|
||||
if (ARGON2_MAX_MEMORY < context->m_cost) { |
||||
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; |
||||
} |
||||
|
||||
if (ARGON2_MAX_TIME < context->t_cost) { |
||||
return ARGON2_TIME_TOO_LARGE; |
||||
} |
||||
|
||||
/* Validate lanes */ |
||||
if (ARGON2_MIN_LANES > context->lanes) { |
||||
return ARGON2_LANES_TOO_FEW; |
||||
} |
||||
|
||||
if (ARGON2_MAX_LANES < context->lanes) { |
||||
return ARGON2_LANES_TOO_MANY; |
||||
} |
||||
|
||||
/* Validate threads */ |
||||
if (ARGON2_MIN_THREADS > context->threads) { |
||||
return ARGON2_THREADS_TOO_FEW; |
||||
} |
||||
|
||||
if (ARGON2_MAX_THREADS < context->threads) { |
||||
return ARGON2_THREADS_TOO_MANY; |
||||
} |
||||
|
||||
if (NULL != context->allocate_cbk && NULL == context->free_cbk) { |
||||
return ARGON2_FREE_MEMORY_CBK_NULL; |
||||
} |
||||
|
||||
if (NULL == context->allocate_cbk && NULL != context->free_cbk) { |
||||
return ARGON2_ALLOCATE_MEMORY_CBK_NULL; |
||||
} |
||||
|
||||
return ARGON2_OK; |
||||
} |
||||
|
||||
void fill_first_blocks(uint8_t *blockhash, const argon2_instance_t *instance) { |
||||
uint32_t l; |
||||
/* Make the first and second block in each lane as G(H0||0||i) or
|
||||
G(H0||1||i) */ |
||||
uint8_t blockhash_bytes[ARGON2_BLOCK_SIZE]; |
||||
for (l = 0; l < instance->lanes; ++l) { |
||||
|
||||
store32(blockhash + ARGON2_PREHASH_DIGEST_LENGTH, 0); |
||||
store32(blockhash + ARGON2_PREHASH_DIGEST_LENGTH + 4, l); |
||||
blake2b_long(blockhash_bytes, ARGON2_BLOCK_SIZE, blockhash, |
||||
ARGON2_PREHASH_SEED_LENGTH); |
||||
load_block(&instance->memory[l * instance->lane_length + 0], |
||||
blockhash_bytes); |
||||
|
||||
store32(blockhash + ARGON2_PREHASH_DIGEST_LENGTH, 1); |
||||
blake2b_long(blockhash_bytes, ARGON2_BLOCK_SIZE, blockhash, |
||||
ARGON2_PREHASH_SEED_LENGTH); |
||||
load_block(&instance->memory[l * instance->lane_length + 1], |
||||
blockhash_bytes); |
||||
} |
||||
clear_internal_memory(blockhash_bytes, ARGON2_BLOCK_SIZE); |
||||
} |
||||
|
||||
void initial_hash(uint8_t *blockhash, argon2_context *context, |
||||
argon2_type type) { |
||||
blake2b_state BlakeHash; |
||||
uint8_t value[sizeof(uint32_t)]; |
||||
|
||||
if (NULL == context || NULL == blockhash) { |
||||
return; |
||||
} |
||||
|
||||
blake2b_init(&BlakeHash, ARGON2_PREHASH_DIGEST_LENGTH); |
||||
|
||||
store32(&value, context->lanes); |
||||
blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value)); |
||||
|
||||
store32(&value, context->outlen); |
||||
blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value)); |
||||
|
||||
store32(&value, context->m_cost); |
||||
blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value)); |
||||
|
||||
store32(&value, context->t_cost); |
||||
blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value)); |
||||
|
||||
store32(&value, context->version); |
||||
blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value)); |
||||
|
||||
store32(&value, (uint32_t)type); |
||||
blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value)); |
||||
|
||||
store32(&value, context->pwdlen); |
||||
blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value)); |
||||
|
||||
if (context->pwd != NULL) { |
||||
blake2b_update(&BlakeHash, (const uint8_t *)context->pwd, |
||||
context->pwdlen); |
||||
|
||||
if (context->flags & ARGON2_FLAG_CLEAR_PASSWORD) { |
||||
secure_wipe_memory(context->pwd, context->pwdlen); |
||||
context->pwdlen = 0; |
||||
} |
||||
} |
||||
|
||||
store32(&value, context->saltlen); |
||||
blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value)); |
||||
|
||||
if (context->salt != NULL) { |
||||
blake2b_update(&BlakeHash, (const uint8_t *)context->salt, |
||||
context->saltlen); |
||||
} |
||||
|
||||
store32(&value, context->secretlen); |
||||
blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value)); |
||||
|
||||
if (context->secret != NULL) { |
||||
blake2b_update(&BlakeHash, (const uint8_t *)context->secret, |
||||
context->secretlen); |
||||
|
||||
if (context->flags & ARGON2_FLAG_CLEAR_SECRET) { |
||||
secure_wipe_memory(context->secret, context->secretlen); |
||||
context->secretlen = 0; |
||||
} |
||||
} |
||||
|
||||
store32(&value, context->adlen); |
||||
blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value)); |
||||
|
||||
if (context->ad != NULL) { |
||||
blake2b_update(&BlakeHash, (const uint8_t *)context->ad, |
||||
context->adlen); |
||||
} |
||||
|
||||
blake2b_final(&BlakeHash, blockhash, ARGON2_PREHASH_DIGEST_LENGTH); |
||||
} |
||||
|
||||
int initialize(argon2_instance_t *instance, argon2_context *context) { |
||||
uint8_t blockhash[ARGON2_PREHASH_SEED_LENGTH]; |
||||
int result = ARGON2_OK; |
||||
|
||||
if (instance == NULL || context == NULL) |
||||
return ARGON2_INCORRECT_PARAMETER; |
||||
instance->context_ptr = context; |
||||
|
||||
/* 1. Memory allocation */ |
||||
result = allocate_memory(context, (uint8_t **)&(instance->memory), |
||||
instance->memory_blocks, sizeof(block)); |
||||
if (result != ARGON2_OK) { |
||||
return result; |
||||
} |
||||
|
||||
/* 2. Initial hashing */ |
||||
/* H_0 + 8 extra bytes to produce the first blocks */ |
||||
/* uint8_t blockhash[ARGON2_PREHASH_SEED_LENGTH]; */ |
||||
/* Hashing all inputs */ |
||||
initial_hash(blockhash, context, instance->type); |
||||
/* Zeroing 8 extra bytes */ |
||||
clear_internal_memory(blockhash + ARGON2_PREHASH_DIGEST_LENGTH, |
||||
ARGON2_PREHASH_SEED_LENGTH - |
||||
ARGON2_PREHASH_DIGEST_LENGTH); |
||||
|
||||
#ifdef GENKAT |
||||
initial_kat(blockhash, context, instance->type); |
||||
#endif |
||||
|
||||
/* 3. Creating first blocks, we always have at least two blocks in a slice
|
||||
*/ |
||||
fill_first_blocks(blockhash, instance); |
||||
/* Clearing the hash */ |
||||
clear_internal_memory(blockhash, ARGON2_PREHASH_SEED_LENGTH); |
||||
|
||||
return ARGON2_OK; |
||||
} |
||||
@ -0,0 +1,228 @@
|
||||
/*
|
||||
* 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 : http://creativecommons.org/publicdomain/zero/1.0
|
||||
* - Apache 2.0 : http://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. |
||||
*/ |
||||
|
||||
#ifndef ARGON2_CORE_H |
||||
#define ARGON2_CORE_H |
||||
|
||||
#include "argon2.h" |
||||
|
||||
#define CONST_CAST(x) (x)(uintptr_t) |
||||
|
||||
/**********************Argon2 internal constants*******************************/ |
||||
|
||||
enum argon2_core_constants { |
||||
/* Memory block size in bytes */ |
||||
ARGON2_BLOCK_SIZE = 1024, |
||||
ARGON2_QWORDS_IN_BLOCK = ARGON2_BLOCK_SIZE / 8, |
||||
ARGON2_OWORDS_IN_BLOCK = ARGON2_BLOCK_SIZE / 16, |
||||
ARGON2_HWORDS_IN_BLOCK = ARGON2_BLOCK_SIZE / 32, |
||||
ARGON2_512BIT_WORDS_IN_BLOCK = ARGON2_BLOCK_SIZE / 64, |
||||
|
||||
/* Number of pseudo-random values generated by one call to Blake in Argon2i
|
||||
to |
||||
generate reference block positions */ |
||||
ARGON2_ADDRESSES_IN_BLOCK = 128, |
||||
|
||||
/* Pre-hashing digest length and its extension*/ |
||||
ARGON2_PREHASH_DIGEST_LENGTH = 64, |
||||
ARGON2_PREHASH_SEED_LENGTH = 72 |
||||
}; |
||||
|
||||
/*************************Argon2 internal data types***********************/ |
||||
|
||||
/*
|
||||
* Structure for the (1KB) memory block implemented as 128 64-bit words. |
||||
* Memory blocks can be copied, XORed. Internal words can be accessed by [] (no |
||||
* bounds checking). |
||||
*/ |
||||
typedef struct block_ { uint64_t v[ARGON2_QWORDS_IN_BLOCK]; } block; |
||||
|
||||
/*****************Functions that work with the block******************/ |
||||
|
||||
/* Initialize each byte of the block with @in */ |
||||
void init_block_value(block *b, uint8_t in); |
||||
|
||||
/* Copy block @src to block @dst */ |
||||
void copy_block(block *dst, const block *src); |
||||
|
||||
/* XOR @src onto @dst bytewise */ |
||||
void xor_block(block *dst, const block *src); |
||||
|
||||
/*
|
||||
* Argon2 instance: memory pointer, number of passes, amount of memory, type, |
||||
* and derived values. |
||||
* Used to evaluate the number and location of blocks to construct in each |
||||
* thread |
||||
*/ |
||||
typedef struct Argon2_instance_t { |
||||
block *memory; /* Memory pointer */ |
||||
uint32_t version; |
||||
uint32_t passes; /* Number of passes */ |
||||
uint32_t memory_blocks; /* Number of blocks in memory */ |
||||
uint32_t segment_length; |
||||
uint32_t lane_length; |
||||
uint32_t lanes; |
||||
uint32_t threads; |
||||
argon2_type type; |
||||
int print_internals; /* whether to print the memory blocks */ |
||||
argon2_context *context_ptr; /* points back to original context */ |
||||
} argon2_instance_t; |
||||
|
||||
/*
|
||||
* Argon2 position: where we construct the block right now. Used to distribute |
||||
* work between threads. |
||||
*/ |
||||
typedef struct Argon2_position_t { |
||||
uint32_t pass; |
||||
uint32_t lane; |
||||
uint8_t slice; |
||||
uint32_t index; |
||||
} argon2_position_t; |
||||
|
||||
/*Struct that holds the inputs for thread handling FillSegment*/ |
||||
typedef struct Argon2_thread_data { |
||||
argon2_instance_t *instance_ptr; |
||||
argon2_position_t pos; |
||||
} argon2_thread_data; |
||||
|
||||
/*************************Argon2 core functions********************************/ |
||||
|
||||
/* Allocates memory to the given pointer, uses the appropriate allocator as
|
||||
* specified in the context. Total allocated memory is num*size. |
||||
* @param context argon2_context which specifies the allocator |
||||
* @param memory pointer to the pointer to the memory |
||||
* @param size the size in bytes for each element to be allocated |
||||
* @param num the number of elements to be allocated |
||||
* @return ARGON2_OK if @memory is a valid pointer and memory is allocated |
||||
*/ |
||||
int allocate_memory(const argon2_context *context, uint8_t **memory, |
||||
size_t num, size_t size); |
||||
|
||||
/*
|
||||
* Frees memory at the given pointer, uses the appropriate deallocator as |
||||
* specified in the context. Also cleans the memory using clear_internal_memory. |
||||
* @param context argon2_context which specifies the deallocator |
||||
* @param memory pointer to buffer to be freed |
||||
* @param size the size in bytes for each element to be deallocated |
||||
* @param num the number of elements to be deallocated |
||||
*/ |
||||
void free_memory(const argon2_context *context, uint8_t *memory, |
||||
size_t num, size_t size); |
||||
|
||||
/* Function that securely cleans the memory. This ignores any flags set
|
||||
* regarding clearing memory. Usually one just calls clear_internal_memory. |
||||
* @param mem Pointer to the memory |
||||
* @param s Memory size in bytes |
||||
*/ |
||||
void secure_wipe_memory(void *v, size_t n); |
||||
|
||||
/* Function that securely clears the memory if FLAG_clear_internal_memory is
|
||||
* set. If the flag isn't set, this function does nothing. |
||||
* @param mem Pointer to the memory |
||||
* @param s Memory size in bytes |
||||
*/ |
||||
void clear_internal_memory(void *v, size_t n); |
||||
|
||||
/*
|
||||
* Computes absolute position of reference block in the lane following a skewed |
||||
* distribution and using a pseudo-random value as input |
||||
* @param instance Pointer to the current instance |
||||
* @param position Pointer to the current position |
||||
* @param pseudo_rand 32-bit pseudo-random value used to determine the position |
||||
* @param same_lane Indicates if the block will be taken from the current lane. |
||||
* If so we can reference the current segment |
||||
* @pre All pointers must be valid |
||||
*/ |
||||
uint32_t index_alpha(const argon2_instance_t *instance, |
||||
const argon2_position_t *position, uint32_t pseudo_rand, |
||||
int same_lane); |
||||
|
||||
/*
|
||||
* Function that validates all inputs against predefined restrictions and return |
||||
* an error code |
||||
* @param context Pointer to current Argon2 context |
||||
* @return ARGON2_OK if everything is all right, otherwise one of error codes |
||||
* (all defined in <argon2.h> |
||||
*/ |
||||
int validate_inputs(const argon2_context *context); |
||||
|
||||
/*
|
||||
* Hashes all the inputs into @a blockhash[PREHASH_DIGEST_LENGTH], clears |
||||
* password and secret if needed |
||||
* @param context Pointer to the Argon2 internal structure containing memory |
||||
* pointer, and parameters for time and space requirements. |
||||
* @param blockhash Buffer for pre-hashing digest |
||||
* @param type Argon2 type |
||||
* @pre @a blockhash must have at least @a PREHASH_DIGEST_LENGTH bytes |
||||
* allocated |
||||
*/ |
||||
void initial_hash(uint8_t *blockhash, argon2_context *context, |
||||
argon2_type type); |
||||
|
||||
/*
|
||||
* Function creates first 2 blocks per lane |
||||
* @param instance Pointer to the current instance |
||||
* @param blockhash Pointer to the pre-hashing digest |
||||
* @pre blockhash must point to @a PREHASH_SEED_LENGTH allocated values |
||||
*/ |
||||
void fill_first_blocks(uint8_t *blockhash, const argon2_instance_t *instance); |
||||
|
||||
/*
|
||||
* Function allocates memory, hashes the inputs with Blake, and creates first |
||||
* two blocks. Returns the pointer to the main memory with 2 blocks per lane |
||||
* initialized |
||||
* @param context Pointer to the Argon2 internal structure containing memory |
||||
* pointer, and parameters for time and space requirements. |
||||
* @param instance Current Argon2 instance |
||||
* @return Zero if successful, -1 if memory failed to allocate. @context->state |
||||
* will be modified if successful. |
||||
*/ |
||||
int initialize(argon2_instance_t *instance, argon2_context *context); |
||||
|
||||
/*
|
||||
* XORing the last block of each lane, hashing it, making the tag. Deallocates |
||||
* the memory. |
||||
* @param context Pointer to current Argon2 context (use only the out parameters |
||||
* from it) |
||||
* @param instance Pointer to current instance of Argon2 |
||||
* @pre instance->state must point to necessary amount of memory |
||||
* @pre context->out must point to outlen bytes of memory |
||||
* @pre if context->free_cbk is not NULL, it should point to a function that |
||||
* deallocates memory |
||||
*/ |
||||
void finalize(const argon2_context *context, argon2_instance_t *instance); |
||||
|
||||
/*
|
||||
* Function that fills the segment using previous segments also from other |
||||
* threads |
||||
* @param context current context |
||||
* @param instance Pointer to the current instance |
||||
* @param position Current position |
||||
* @pre all block pointers must be valid |
||||
*/ |
||||
void fill_segment(const argon2_instance_t *instance, |
||||
argon2_position_t position); |
||||
|
||||
/*
|
||||
* Function that fills the entire memory t_cost times based on the first two |
||||
* blocks in each lane |
||||
* @param instance Pointer to the current instance |
||||
* @return ARGON2_OK if successful, @context->state |
||||
*/ |
||||
int fill_memory_blocks(argon2_instance_t *instance); |
||||
|
||||
#endif |
||||
@ -0,0 +1,463 @@
|
||||
/*
|
||||
* 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 : http://creativecommons.org/publicdomain/zero/1.0
|
||||
* - Apache 2.0 : http://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 <stdlib.h> |
||||
#include <string.h> |
||||
#include <limits.h> |
||||
#include "encoding.h" |
||||
#include "core.h" |
||||
|
||||
/*
|
||||
* Example code for a decoder and encoder of "hash strings", with Argon2 |
||||
* parameters. |
||||
* |
||||
* This code comprises three sections: |
||||
* |
||||
* -- The first section contains generic Base64 encoding and decoding |
||||
* functions. It is conceptually applicable to any hash function |
||||
* implementation that uses Base64 to encode and decode parameters, |
||||
* salts and outputs. It could be made into a library, provided that |
||||
* the relevant functions are made public (non-static) and be given |
||||
* reasonable names to avoid collisions with other functions. |
||||
* |
||||
* -- The second section is specific to Argon2. It encodes and decodes |
||||
* the parameters, salts and outputs. It does not compute the hash |
||||
* itself. |
||||
* |
||||
* The code was originally written by Thomas Pornin <pornin@bolet.org>, |
||||
* to whom comments and remarks may be sent. It is released under what |
||||
* should amount to Public Domain or its closest equivalent; the |
||||
* following mantra is supposed to incarnate that fact with all the |
||||
* proper legal rituals: |
||||
* |
||||
* --------------------------------------------------------------------- |
||||
* This file is provided under the terms of Creative Commons CC0 1.0 |
||||
* Public Domain Dedication. To the extent possible under law, the |
||||
* author (Thomas Pornin) has waived all copyright and related or |
||||
* neighboring rights to this file. This work is published from: Canada. |
||||
* --------------------------------------------------------------------- |
||||
* |
||||
* Copyright (c) 2015 Thomas Pornin |
||||
*/ |
||||
|
||||
/* ==================================================================== */ |
||||
/*
|
||||
* Common code; could be shared between different hash functions. |
||||
* |
||||
* Note: the Base64 functions below assume that uppercase letters (resp. |
||||
* lowercase letters) have consecutive numerical codes, that fit on 8 |
||||
* bits. All modern systems use ASCII-compatible charsets, where these |
||||
* properties are true. If you are stuck with a dinosaur of a system |
||||
* that still defaults to EBCDIC then you already have much bigger |
||||
* interoperability issues to deal with. |
||||
*/ |
||||
|
||||
/*
|
||||
* 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) ((((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) |
||||
#define LE(x, y) GE(y, x) |
||||
|
||||
/*
|
||||
* Convert value x (0..63) to corresponding Base64 character. |
||||
*/ |
||||
static int b64_byte_to_char(unsigned x) { |
||||
return (LT(x, 26) & (x + 'A')) | |
||||
(GE(x, 26) & LT(x, 52) & (x + ('a' - 26))) | |
||||
(GE(x, 52) & LT(x, 62) & (x + ('0' - 52))) | (EQ(x, 62) & '+') | |
||||
(EQ(x, 63) & '/'); |
||||
} |
||||
|
||||
/*
|
||||
* Convert character c to the corresponding 6-bit value. If character c |
||||
* is not a Base64 character, then 0xFF (255) is returned. |
||||
*/ |
||||
static unsigned b64_char_to_byte(int c) { |
||||
unsigned x; |
||||
|
||||
x = (GE(c, 'A') & LE(c, 'Z') & (c - 'A')) | |
||||
(GE(c, 'a') & LE(c, 'z') & (c - ('a' - 26))) | |
||||
(GE(c, '0') & LE(c, '9') & (c - ('0' - 52))) | (EQ(c, '+') & 62) | |
||||
(EQ(c, '/') & 63); |
||||
return x | (EQ(x, 0) & (EQ(c, 'A') ^ 0xFF)); |
||||
} |
||||
|
||||
/*
|
||||
* Convert some bytes to Base64. 'dst_len' is the length (in characters) |
||||
* of the output buffer 'dst'; if that buffer is not large enough to |
||||
* receive the result (including the terminating 0), then (size_t)-1 |
||||
* is returned. Otherwise, the zero-terminated Base64 string is written |
||||
* in the buffer, and the output length (counted WITHOUT the terminating |
||||
* zero) is returned. |
||||
*/ |
||||
static size_t to_base64(char *dst, size_t dst_len, const void *src, |
||||
size_t src_len) { |
||||
size_t olen; |
||||
const unsigned char *buf; |
||||
unsigned acc, acc_len; |
||||
|
||||
olen = (src_len / 3) << 2; |
||||
switch (src_len % 3) { |
||||
case 2: |
||||
olen++; |
||||
/* fall through */ |
||||
case 1: |
||||
olen += 2; |
||||
break; |
||||
} |
||||
if (dst_len <= olen) { |
||||
return (size_t)-1; |
||||
} |
||||
acc = 0; |
||||
acc_len = 0; |
||||
buf = (const unsigned char *)src; |
||||
while (src_len-- > 0) { |
||||
acc = (acc << 8) + (*buf++); |
||||
acc_len += 8; |
||||
while (acc_len >= 6) { |
||||
acc_len -= 6; |
||||
*dst++ = (char)b64_byte_to_char((acc >> acc_len) & 0x3F); |
||||
} |
||||
} |
||||
if (acc_len > 0) { |
||||
*dst++ = (char)b64_byte_to_char((acc << (6 - acc_len)) & 0x3F); |
||||
} |
||||
*dst++ = 0; |
||||
return olen; |
||||
} |
||||
|
||||
/*
|
||||
* Decode Base64 chars into bytes. The '*dst_len' value must initially |
||||
* contain the length of the output buffer '*dst'; when the decoding |
||||
* ends, the actual number of decoded bytes is written back in |
||||
* '*dst_len'. |
||||
* |
||||
* Decoding stops when a non-Base64 character is encountered, or when |
||||
* the output buffer capacity is exceeded. If an error occurred (output |
||||
* buffer is too small, invalid last characters leading to unprocessed |
||||
* buffered bits), then NULL is returned; otherwise, the returned value |
||||
* points to the first non-Base64 character in the source stream, which |
||||
* may be the terminating zero. |
||||
*/ |
||||
static const char *from_base64(void *dst, size_t *dst_len, const char *src) { |
||||
size_t len; |
||||
unsigned char *buf; |
||||
unsigned acc, acc_len; |
||||
|
||||
buf = (unsigned char *)dst; |
||||
len = 0; |
||||
acc = 0; |
||||
acc_len = 0; |
||||
for (;;) { |
||||
unsigned d; |
||||
|
||||
d = b64_char_to_byte(*src); |
||||
if (d == 0xFF) { |
||||
break; |
||||
} |
||||
src++; |
||||
acc = (acc << 6) + d; |
||||
acc_len += 6; |
||||
if (acc_len >= 8) { |
||||
acc_len -= 8; |
||||
if ((len++) >= *dst_len) { |
||||
return NULL; |
||||
} |
||||
*buf++ = (acc >> acc_len) & 0xFF; |
||||
} |
||||
} |
||||
|
||||
/*
|
||||
* If the input length is equal to 1 modulo 4 (which is |
||||
* invalid), then there will remain 6 unprocessed bits; |
||||
* otherwise, only 0, 2 or 4 bits are buffered. The buffered |
||||
* bits must also all be zero. |
||||
*/ |
||||
if (acc_len > 4 || (acc & (((unsigned)1 << acc_len) - 1)) != 0) { |
||||
return NULL; |
||||
} |
||||
*dst_len = len; |
||||
return src; |
||||
} |
||||
|
||||
/*
|
||||
* Decode decimal integer from 'str'; the value is written in '*v'. |
||||
* Returned value is a pointer to the next non-decimal character in the |
||||
* string. If there is no digit at all, or the value encoding is not |
||||
* minimal (extra leading zeros), or the value does not fit in an |
||||
* 'unsigned long', then NULL is returned. |
||||
*/ |
||||
static const char *decode_decimal(const char *str, unsigned long *v) { |
||||
const char *orig; |
||||
unsigned long acc; |
||||
|
||||
acc = 0; |
||||
for (orig = str;; str++) { |
||||
int c; |
||||
|
||||
c = *str; |
||||
if (c < '0' || c > '9') { |
||||
break; |
||||
} |
||||
c -= '0'; |
||||
if (acc > (ULONG_MAX / 10)) { |
||||
return NULL; |
||||
} |
||||
acc *= 10; |
||||
if ((unsigned long)c > (ULONG_MAX - acc)) { |
||||
return NULL; |
||||
} |
||||
acc += (unsigned long)c; |
||||
} |
||||
if (str == orig || (*orig == '0' && str != (orig + 1))) { |
||||
return NULL; |
||||
} |
||||
*v = acc; |
||||
return str; |
||||
} |
||||
|
||||
/* ==================================================================== */ |
||||
/*
|
||||
* Code specific to Argon2. |
||||
* |
||||
* The code below applies the following format: |
||||
* |
||||
* $argon2<T>[$v=<num>]$m=<num>,t=<num>,p=<num>$<bin>$<bin> |
||||
* |
||||
* where <T> is either 'd', 'id', or 'i', <num> is a decimal integer (positive, |
||||
* fits in an 'unsigned long'), and <bin> is Base64-encoded data (no '=' padding |
||||
* characters, no newline or whitespace). |
||||
* |
||||
* The last two binary chunks (encoded in Base64) are, in that order, |
||||
* the salt and the output. Both are required. The binary salt length and the |
||||
* output length must be in the allowed ranges defined in argon2.h. |
||||
* |
||||
* The ctx struct must contain buffers large enough to hold the salt and pwd |
||||
* when it is fed into decode_string. |
||||
*/ |
||||
|
||||
int decode_string(argon2_context *ctx, const char *str, argon2_type type) { |
||||
|
||||
/* check for prefix */ |
||||
#define CC(prefix) \ |
||||
do { \
|
||||
size_t cc_len = strlen(prefix); \
|
||||
if (strncmp(str, prefix, cc_len) != 0) { \
|
||||
return ARGON2_DECODING_FAIL; \
|
||||
} \
|
||||
str += cc_len; \
|
||||
} while ((void)0, 0) |
||||
|
||||
/* optional prefix checking with supplied code */ |
||||
#define CC_opt(prefix, code) \ |
||||
do { \
|
||||
size_t cc_len = strlen(prefix); \
|
||||
if (strncmp(str, prefix, cc_len) == 0) { \
|
||||
str += cc_len; \
|
||||
{ code; } \
|
||||
} \
|
||||
} while ((void)0, 0) |
||||
|
||||
/* Decoding prefix into decimal */ |
||||
#define DECIMAL(x) \ |
||||
do { \
|
||||
unsigned long dec_x; \
|
||||
str = decode_decimal(str, &dec_x); \
|
||||
if (str == NULL) { \
|
||||
return ARGON2_DECODING_FAIL; \
|
||||
} \
|
||||
(x) = dec_x; \
|
||||
} while ((void)0, 0) |
||||
|
||||
|
||||
/* Decoding prefix into uint32_t decimal */ |
||||
#define DECIMAL_U32(x) \ |
||||
do { \
|
||||
unsigned long dec_x; \
|
||||
str = decode_decimal(str, &dec_x); \
|
||||
if (str == NULL || dec_x > UINT32_MAX) { \
|
||||
return ARGON2_DECODING_FAIL; \
|
||||
} \
|
||||
(x) = (uint32_t)dec_x; \
|
||||
} while ((void)0, 0) |
||||
|
||||
|
||||
/* Decoding base64 into a binary buffer */ |
||||
#define BIN(buf, max_len, len) \ |
||||
do { \
|
||||
size_t bin_len = (max_len); \
|
||||
str = from_base64(buf, &bin_len, str); \
|
||||
if (str == NULL || bin_len > UINT32_MAX) { \
|
||||
return ARGON2_DECODING_FAIL; \
|
||||
} \
|
||||
(len) = (uint32_t)bin_len; \
|
||||
} while ((void)0, 0) |
||||
|
||||
size_t maxsaltlen = ctx->saltlen; |
||||
size_t maxoutlen = ctx->outlen; |
||||
int validation_result; |
||||
const char* type_string; |
||||
|
||||
/* We should start with the argon2_type we are using */ |
||||
type_string = argon2_type2string(type, 0); |
||||
if (!type_string) { |
||||
return ARGON2_INCORRECT_TYPE; |
||||
} |
||||
|
||||
CC("$"); |
||||
CC(type_string); |
||||
|
||||
/* Reading the version number if the default is suppressed */ |
||||
ctx->version = ARGON2_VERSION_10; |
||||
CC_opt("$v=", DECIMAL_U32(ctx->version)); |
||||
|
||||
CC("$m="); |
||||
DECIMAL_U32(ctx->m_cost); |
||||
CC(",t="); |
||||
DECIMAL_U32(ctx->t_cost); |
||||
CC(",p="); |
||||
DECIMAL_U32(ctx->lanes); |
||||
ctx->threads = ctx->lanes; |
||||
|
||||
CC("$"); |
||||
BIN(ctx->salt, maxsaltlen, ctx->saltlen); |
||||
CC("$"); |
||||
BIN(ctx->out, maxoutlen, ctx->outlen); |
||||
|
||||
/* The rest of the fields get the default values */ |
||||
ctx->secret = NULL; |
||||
ctx->secretlen = 0; |
||||
ctx->ad = NULL; |
||||
ctx->adlen = 0; |
||||
ctx->allocate_cbk = NULL; |
||||
ctx->free_cbk = NULL; |
||||
ctx->flags = ARGON2_DEFAULT_FLAGS; |
||||
|
||||
/* On return, must have valid context */ |
||||
validation_result = validate_inputs(ctx); |
||||
if (validation_result != ARGON2_OK) { |
||||
return validation_result; |
||||
} |
||||
|
||||
/* Can't have any additional characters */ |
||||
if (*str == 0) { |
||||
return ARGON2_OK; |
||||
} else { |
||||
return ARGON2_DECODING_FAIL; |
||||
} |
||||
#undef CC |
||||
#undef CC_opt |
||||
#undef DECIMAL |
||||
#undef BIN |
||||
} |
||||
|
||||
int encode_string(char *dst, size_t dst_len, argon2_context *ctx, |
||||
argon2_type type) { |
||||
#define SS(str) \ |
||||
do { \
|
||||
size_t pp_len = strlen(str); \
|
||||
if (pp_len >= dst_len) { \
|
||||
return ARGON2_ENCODING_FAIL; \
|
||||
} \
|
||||
memcpy(dst, str, pp_len + 1); \
|
||||
dst += pp_len; \
|
||||
dst_len -= pp_len; \
|
||||
} while ((void)0, 0) |
||||
|
||||
#define SX(x) \ |
||||
do { \
|
||||
char tmp[30]; \
|
||||
sprintf(tmp, "%lu", (unsigned long)(x)); \
|
||||
SS(tmp); \
|
||||
} while ((void)0, 0) |
||||
|
||||
#define SB(buf, len) \ |
||||
do { \
|
||||
size_t sb_len = to_base64(dst, dst_len, buf, len); \
|
||||
if (sb_len == (size_t)-1) { \
|
||||
return ARGON2_ENCODING_FAIL; \
|
||||
} \
|
||||
dst += sb_len; \
|
||||
dst_len -= sb_len; \
|
||||
} while ((void)0, 0) |
||||
|
||||
const char* type_string = argon2_type2string(type, 0); |
||||
int validation_result = validate_inputs(ctx); |
||||
|
||||
if (!type_string) { |
||||
return ARGON2_ENCODING_FAIL; |
||||
} |
||||
|
||||
if (validation_result != ARGON2_OK) { |
||||
return validation_result; |
||||
} |
||||
|
||||
|
||||
SS("$"); |
||||
SS(type_string); |
||||
|
||||
SS("$v="); |
||||
SX(ctx->version); |
||||
|
||||
SS("$m="); |
||||
SX(ctx->m_cost); |
||||
SS(",t="); |
||||
SX(ctx->t_cost); |
||||
SS(",p="); |
||||
SX(ctx->lanes); |
||||
|
||||
SS("$"); |
||||
SB(ctx->salt, ctx->saltlen); |
||||
|
||||
SS("$"); |
||||
SB(ctx->out, ctx->outlen); |
||||
return ARGON2_OK; |
||||
|
||||
#undef SS |
||||
#undef SX |
||||
#undef SB |
||||
} |
||||
|
||||
size_t b64len(uint32_t len) { |
||||
size_t olen = ((size_t)len / 3) << 2; |
||||
|
||||
switch (len % 3) { |
||||
case 2: |
||||
olen++; |
||||
/* fall through */ |
||||
case 1: |
||||
olen += 2; |
||||
break; |
||||
} |
||||
|
||||
return olen; |
||||
} |
||||
|
||||
size_t numlen(uint32_t num) { |
||||
size_t len = 1; |
||||
while (num >= 10) { |
||||
++len; |
||||
num = num / 10; |
||||
} |
||||
return len; |
||||
} |
||||
|
||||
@ -0,0 +1,57 @@
|
||||
/*
|
||||
* 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 : http://creativecommons.org/publicdomain/zero/1.0
|
||||
* - Apache 2.0 : http://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. |
||||
*/ |
||||
|
||||
#ifndef ENCODING_H |
||||
#define ENCODING_H |
||||
#include "argon2.h" |
||||
|
||||
#define ARGON2_MAX_DECODED_LANES UINT32_C(255) |
||||
#define ARGON2_MIN_DECODED_SALT_LEN UINT32_C(8) |
||||
#define ARGON2_MIN_DECODED_OUT_LEN UINT32_C(12) |
||||
|
||||
/*
|
||||
* encode an Argon2 hash string into the provided buffer. 'dst_len' |
||||
* contains the size, in characters, of the 'dst' buffer; if 'dst_len' |
||||
* is less than the number of required characters (including the |
||||
* terminating 0), then this function returns ARGON2_ENCODING_ERROR. |
||||
* |
||||
* on success, ARGON2_OK is returned. |
||||
*/ |
||||
int encode_string(char *dst, size_t dst_len, argon2_context *ctx, |
||||
argon2_type type); |
||||
|
||||
/*
|
||||
* Decodes an Argon2 hash string into the provided structure 'ctx'. |
||||
* The only fields that must be set prior to this call are ctx.saltlen and |
||||
* ctx.outlen (which must be the maximal salt and out length values that are |
||||
* allowed), ctx.salt and ctx.out (which must be buffers of the specified |
||||
* length), and ctx.pwd and ctx.pwdlen which must hold a valid password. |
||||
* |
||||
* Invalid input string causes an error. On success, the ctx is valid and all |
||||
* fields have been initialized. |
||||
* |
||||
* Returned value is ARGON2_OK on success, other ARGON2_ codes on error. |
||||
*/ |
||||
int decode_string(argon2_context *ctx, const char *str, argon2_type type); |
||||
|
||||
/* Returns the length of the encoded byte stream with length len */ |
||||
size_t b64len(uint32_t len); |
||||
|
||||
/* Returns the length of the encoded number num */ |
||||
size_t numlen(uint32_t num); |
||||
|
||||
#endif |
||||
@ -0,0 +1,207 @@
|
||||
/*
|
||||
* 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 : http://creativecommons.org/publicdomain/zero/1.0
|
||||
* - Apache 2.0 : http://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 <stdlib.h> |
||||
#include <string.h> |
||||
#include "argon2.h" |
||||
#include "core.h" |
||||
|
||||
void initial_kat(const uint8_t *blockhash, const argon2_context *context, |
||||
argon2_type type) { |
||||
unsigned i; |
||||
|
||||
if (blockhash != NULL && context != NULL) { |
||||
printf("=======================================\n"); |
||||
|
||||
printf("%s version number %d\n", argon2_type2string(type, 1), |
||||
context->version); |
||||
|
||||
printf("=======================================\n"); |
||||
|
||||
|
||||
printf("Memory: %u KiB, Iterations: %u, Parallelism: %u lanes, Tag " |
||||
"length: %u bytes\n", |
||||
context->m_cost, context->t_cost, context->lanes, |
||||
context->outlen); |
||||
|
||||
printf("Password[%u]: ", context->pwdlen); |
||||
|
||||
if (context->flags & ARGON2_FLAG_CLEAR_PASSWORD) { |
||||
printf("CLEARED\n"); |
||||
} else { |
||||
for (i = 0; i < context->pwdlen; ++i) { |
||||
printf("%2.2x ", ((unsigned char *)context->pwd)[i]); |
||||
} |
||||
|
||||
printf("\n"); |
||||
} |
||||
|
||||
printf("Salt[%u]: ", context->saltlen); |
||||
|
||||
for (i = 0; i < context->saltlen; ++i) { |
||||
printf("%2.2x ", ((unsigned char *)context->salt)[i]); |
||||
} |
||||
|
||||
printf("\n"); |
||||
|
||||
printf("Secret[%u]: ", context->secretlen); |
||||
|
||||
if (context->flags & ARGON2_FLAG_CLEAR_SECRET) { |
||||
printf("CLEARED\n"); |
||||
} else { |
||||
for (i = 0; i < context->secretlen; ++i) { |
||||
printf("%2.2x ", ((unsigned char *)context->secret)[i]); |
||||
} |
||||
|
||||
printf("\n"); |
||||
} |
||||
|
||||
printf("Associated data[%u]: ", context->adlen); |
||||
|
||||
for (i = 0; i < context->adlen; ++i) { |
||||
printf("%2.2x ", ((unsigned char *)context->ad)[i]); |
||||
} |
||||
|
||||
printf("\n"); |
||||
|
||||
printf("Pre-hashing digest: "); |
||||
|
||||
for (i = 0; i < ARGON2_PREHASH_DIGEST_LENGTH; ++i) { |
||||
printf("%2.2x ", ((unsigned char *)blockhash)[i]); |
||||
} |
||||
|
||||
printf("\n"); |
||||
} |
||||
} |
||||
|
||||
void print_tag(const void *out, uint32_t outlen) { |
||||
unsigned i; |
||||
if (out != NULL) { |
||||
printf("Tag: "); |
||||
|
||||
for (i = 0; i < outlen; ++i) { |
||||
printf("%2.2x ", ((uint8_t *)out)[i]); |
||||
} |
||||
|
||||
printf("\n"); |
||||
} |
||||
} |
||||
|
||||
void internal_kat(const argon2_instance_t *instance, uint32_t pass) { |
||||
|
||||
if (instance != NULL) { |
||||
uint32_t i, j; |
||||
printf("\n After pass %u:\n", pass); |
||||
|
||||
for (i = 0; i < instance->memory_blocks; ++i) { |
||||
uint32_t how_many_words = |
||||
(instance->memory_blocks > ARGON2_QWORDS_IN_BLOCK) |
||||
? 1 |
||||
: ARGON2_QWORDS_IN_BLOCK; |
||||
|
||||
for (j = 0; j < how_many_words; ++j) |
||||
printf("Block %.4u [%3u]: %016llx\n", i, j, |
||||
(unsigned long long)instance->memory[i].v[j]); |
||||
} |
||||
} |
||||
} |
||||
|
||||
static void fatal(const char *error) { |
||||
fprintf(stderr, "Error: %s\n", error); |
||||
exit(1); |
||||
} |
||||
|
||||
static void generate_testvectors(argon2_type type, const uint32_t version) { |
||||
#define TEST_OUTLEN 32 |
||||
#define TEST_PWDLEN 32 |
||||
#define TEST_SALTLEN 16 |
||||
#define TEST_SECRETLEN 8 |
||||
#define TEST_ADLEN 12 |
||||
argon2_context context; |
||||
|
||||
unsigned char out[TEST_OUTLEN]; |
||||
unsigned char pwd[TEST_PWDLEN]; |
||||
unsigned char salt[TEST_SALTLEN]; |
||||
unsigned char secret[TEST_SECRETLEN]; |
||||
unsigned char ad[TEST_ADLEN]; |
||||
const allocate_fptr myown_allocator = NULL; |
||||
const deallocate_fptr myown_deallocator = NULL; |
||||
|
||||
unsigned t_cost = 3; |
||||
unsigned m_cost = 32; |
||||
unsigned lanes = 4; |
||||
|
||||
memset(pwd, 1, TEST_OUTLEN); |
||||
memset(salt, 2, TEST_SALTLEN); |
||||
memset(secret, 3, TEST_SECRETLEN); |
||||
memset(ad, 4, TEST_ADLEN); |
||||
|
||||
context.out = out; |
||||
context.outlen = TEST_OUTLEN; |
||||
context.version = version; |
||||
context.pwd = pwd; |
||||
context.pwdlen = TEST_PWDLEN; |
||||
context.salt = salt; |
||||
context.saltlen = TEST_SALTLEN; |
||||
context.secret = secret; |
||||
context.secretlen = TEST_SECRETLEN; |
||||
context.ad = ad; |
||||
context.adlen = TEST_ADLEN; |
||||
context.t_cost = t_cost; |
||||
context.m_cost = m_cost; |
||||
context.lanes = lanes; |
||||
context.threads = lanes; |
||||
context.allocate_cbk = myown_allocator; |
||||
context.free_cbk = myown_deallocator; |
||||
context.flags = ARGON2_DEFAULT_FLAGS; |
||||
|
||||
#undef TEST_OUTLEN |
||||
#undef TEST_PWDLEN |
||||
#undef TEST_SALTLEN |
||||
#undef TEST_SECRETLEN |
||||
#undef TEST_ADLEN |
||||
|
||||
argon2_ctx(&context, type); |
||||
} |
||||
|
||||
int main(int argc, char *argv[]) { |
||||
/* Get and check Argon2 type */ |
||||
const char *type_str = (argc > 1) ? argv[1] : "i"; |
||||
argon2_type type = Argon2_i; |
||||
uint32_t version = ARGON2_VERSION_NUMBER; |
||||
if (!strcmp(type_str, "d")) { |
||||
type = Argon2_d; |
||||
} else if (!strcmp(type_str, "i")) { |
||||
type = Argon2_i; |
||||
} else if (!strcmp(type_str, "id")) { |
||||
type = Argon2_id; |
||||
} else { |
||||
fatal("wrong Argon2 type"); |
||||
} |
||||
|
||||
/* Get and check Argon2 version number */ |
||||
if (argc > 2) { |
||||
version = strtoul(argv[2], NULL, 10); |
||||
} |
||||
if (ARGON2_VERSION_10 != version && ARGON2_VERSION_NUMBER != version) { |
||||
fatal("wrong Argon2 version number"); |
||||
} |
||||
|
||||
generate_testvectors(type, version); |
||||
return ARGON2_OK; |
||||
} |
||||
@ -0,0 +1,51 @@
|
||||
/*
|
||||
* 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 : http://creativecommons.org/publicdomain/zero/1.0
|
||||
* - Apache 2.0 : http://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. |
||||
*/ |
||||
|
||||
#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 |
||||
* @param context Holds inputs |
||||
* @param type Argon2 type |
||||
* @pre blockhash must point to INPUT_INITIAL_HASH_LENGTH bytes |
||||
* @pre context member pointers must point to allocated memory of size according |
||||
* to the length values |
||||
*/ |
||||
void initial_kat(const uint8_t *blockhash, const argon2_context *context, |
||||
argon2_type type); |
||||
|
||||
/*
|
||||
* Function that prints the output tag |
||||
* @param out output array pointer |
||||
* @param outlen digest length |
||||
* @pre out must point to @a outlen bytes |
||||
**/ |
||||
void print_tag(const void *out, uint32_t outlen); |
||||
|
||||
/*
|
||||
* Function that prints the internal state at given moment |
||||
* @param instance pointer to the current instance |
||||
* @param pass current pass number |
||||
* @pre instance must have necessary memory allocated |
||||
**/ |
||||
void internal_kat(const argon2_instance_t *instance, uint32_t pass); |
||||
|
||||
#endif |
||||
@ -0,0 +1,194 @@
|
||||
/*
|
||||
* 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 : http://creativecommons.org/publicdomain/zero/1.0
|
||||
* - Apache 2.0 : http://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 <stdint.h> |
||||
#include <string.h> |
||||
#include <stdlib.h> |
||||
|
||||
#include "argon2.h" |
||||
#include "core.h" |
||||
|
||||
#include "blake2/blamka-round-ref.h" |
||||
#include "blake2/blake2-impl.h" |
||||
#include "blake2/blake2.h" |
||||
|
||||
|
||||
/*
|
||||
* Function fills a new memory block and optionally XORs the old block over the new one. |
||||
* @next_block must be initialized. |
||||
* @param prev_block Pointer to the previous block |
||||
* @param ref_block Pointer to the reference block |
||||
* @param next_block Pointer to the block to be constructed |
||||
* @param with_xor Whether to XOR into the new block (1) or just overwrite (0) |
||||
* @pre all block pointers must be valid |
||||
*/ |
||||
static void fill_block(const block *prev_block, const block *ref_block, |
||||
block *next_block, int with_xor) { |
||||
block blockR, block_tmp; |
||||
unsigned i; |
||||
|
||||
copy_block(&blockR, ref_block); |
||||
xor_block(&blockR, prev_block); |
||||
copy_block(&block_tmp, &blockR); |
||||
/* Now blockR = ref_block + prev_block and block_tmp = ref_block + prev_block */ |
||||
if (with_xor) { |
||||
/* Saving the next block contents for XOR over: */ |
||||
xor_block(&block_tmp, next_block); |
||||
/* Now blockR = ref_block + prev_block and
|
||||
block_tmp = ref_block + prev_block + next_block */ |
||||
} |
||||
|
||||
/* Apply Blake2 on columns of 64-bit words: (0,1,...,15) , then
|
||||
(16,17,..31)... finally (112,113,...127) */ |
||||
for (i = 0; i < 8; ++i) { |
||||
BLAKE2_ROUND_NOMSG( |
||||
blockR.v[16 * i], blockR.v[16 * i + 1], blockR.v[16 * i + 2], |
||||
blockR.v[16 * i + 3], blockR.v[16 * i + 4], blockR.v[16 * i + 5], |
||||
blockR.v[16 * i + 6], blockR.v[16 * i + 7], blockR.v[16 * i + 8], |
||||
blockR.v[16 * i + 9], blockR.v[16 * i + 10], blockR.v[16 * i + 11], |
||||
blockR.v[16 * i + 12], blockR.v[16 * i + 13], blockR.v[16 * i + 14], |
||||
blockR.v[16 * i + 15]); |
||||
} |
||||
|
||||
/* Apply Blake2 on rows of 64-bit words: (0,1,16,17,...112,113), then
|
||||
(2,3,18,19,...,114,115).. finally (14,15,30,31,...,126,127) */ |
||||
for (i = 0; i < 8; i++) { |
||||
BLAKE2_ROUND_NOMSG( |
||||
blockR.v[2 * i], blockR.v[2 * i + 1], blockR.v[2 * i + 16], |
||||
blockR.v[2 * i + 17], blockR.v[2 * i + 32], blockR.v[2 * i + 33], |
||||
blockR.v[2 * i + 48], blockR.v[2 * i + 49], blockR.v[2 * i + 64], |
||||
blockR.v[2 * i + 65], blockR.v[2 * i + 80], blockR.v[2 * i + 81], |
||||
blockR.v[2 * i + 96], blockR.v[2 * i + 97], blockR.v[2 * i + 112], |
||||
blockR.v[2 * i + 113]); |
||||
} |
||||
|
||||
copy_block(next_block, &block_tmp); |
||||
xor_block(next_block, &blockR); |
||||
} |
||||
|
||||
static void next_addresses(block *address_block, block *input_block, |
||||
const block *zero_block) { |
||||
input_block->v[6]++; |
||||
fill_block(zero_block, input_block, address_block, 0); |
||||
fill_block(zero_block, address_block, address_block, 0); |
||||
} |
||||
|
||||
void fill_segment(const argon2_instance_t *instance, |
||||
argon2_position_t position) { |
||||
block *ref_block = NULL, *curr_block = NULL; |
||||
block address_block, input_block, zero_block; |
||||
uint64_t pseudo_rand, ref_index, ref_lane; |
||||
uint32_t prev_offset, curr_offset; |
||||
uint32_t starting_index; |
||||
uint32_t i; |
||||
int data_independent_addressing; |
||||
|
||||
if (instance == NULL) { |
||||
return; |
||||
} |
||||
|
||||
data_independent_addressing = |
||||
(instance->type == Argon2_i) || |
||||
(instance->type == Argon2_id && (position.pass == 0) && |
||||
(position.slice < ARGON2_SYNC_POINTS / 2)); |
||||
|
||||
if (data_independent_addressing) { |
||||
init_block_value(&zero_block, 0); |
||||
init_block_value(&input_block, 0); |
||||
|
||||
input_block.v[0] = position.pass; |
||||
input_block.v[1] = position.lane; |
||||
input_block.v[2] = position.slice; |
||||
input_block.v[3] = instance->memory_blocks; |
||||
input_block.v[4] = instance->passes; |
||||
input_block.v[5] = instance->type; |
||||
} |
||||
|
||||
starting_index = 0; |
||||
|
||||
if ((0 == position.pass) && (0 == position.slice)) { |
||||
starting_index = 2; /* we have already generated the first two blocks */ |
||||
|
||||
/* Don't forget to generate the first block of addresses: */ |
||||
if (data_independent_addressing) { |
||||
next_addresses(&address_block, &input_block, &zero_block); |
||||
} |
||||
} |
||||
|
||||
/* Offset of the current block */ |
||||
curr_offset = position.lane * instance->lane_length + |
||||
position.slice * instance->segment_length + starting_index; |
||||
|
||||
if (0 == curr_offset % instance->lane_length) { |
||||
/* Last block in this lane */ |
||||
prev_offset = curr_offset + instance->lane_length - 1; |
||||
} else { |
||||
/* Previous block */ |
||||
prev_offset = curr_offset - 1; |
||||
} |
||||
|
||||
for (i = starting_index; i < instance->segment_length; |
||||
++i, ++curr_offset, ++prev_offset) { |
||||
/*1.1 Rotating prev_offset if needed */ |
||||
if (curr_offset % instance->lane_length == 1) { |
||||
prev_offset = curr_offset - 1; |
||||
} |
||||
|
||||
/* 1.2 Computing the index of the reference block */ |
||||
/* 1.2.1 Taking pseudo-random value from the previous block */ |
||||
if (data_independent_addressing) { |
||||
if (i % ARGON2_ADDRESSES_IN_BLOCK == 0) { |
||||
next_addresses(&address_block, &input_block, &zero_block); |
||||
} |
||||
pseudo_rand = address_block.v[i % ARGON2_ADDRESSES_IN_BLOCK]; |
||||
} else { |
||||
pseudo_rand = instance->memory[prev_offset].v[0]; |
||||
} |
||||
|
||||
/* 1.2.2 Computing the lane of the reference block */ |
||||
ref_lane = ((pseudo_rand >> 32)) % instance->lanes; |
||||
|
||||
if ((position.pass == 0) && (position.slice == 0)) { |
||||
/* Can not reference other lanes yet */ |
||||
ref_lane = position.lane; |
||||
} |
||||
|
||||
/* 1.2.3 Computing the number of possible reference block within the
|
||||
* lane. |
||||
*/ |
||||
position.index = i; |
||||
ref_index = index_alpha(instance, &position, pseudo_rand & 0xFFFFFFFF, |
||||
ref_lane == position.lane); |
||||
|
||||
/* 2 Creating a new block */ |
||||
ref_block = |
||||
instance->memory + instance->lane_length * ref_lane + ref_index; |
||||
curr_block = instance->memory + curr_offset; |
||||
if (ARGON2_VERSION_10 == instance->version) { |
||||
/* version 1.2.1 and earlier: overwrite, not XOR */ |
||||
fill_block(instance->memory + prev_offset, ref_block, curr_block, 0); |
||||
} else { |
||||
if(0 == position.pass) { |
||||
fill_block(instance->memory + prev_offset, ref_block, |
||||
curr_block, 0); |
||||
} else { |
||||
fill_block(instance->memory + prev_offset, ref_block, |
||||
curr_block, 1); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,57 @@
|
||||
/*
|
||||
* 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 : http://creativecommons.org/publicdomain/zero/1.0
|
||||
* - Apache 2.0 : http://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. |
||||
*/ |
||||
|
||||
#if !defined(ARGON2_NO_THREADS) |
||||
|
||||
#include "thread.h" |
||||
#if defined(_WIN32) |
||||
#include <windows.h> |
||||
#endif |
||||
|
||||
int argon2_thread_create(argon2_thread_handle_t *handle, |
||||
argon2_thread_func_t func, void *args) { |
||||
if (NULL == handle || func == NULL) { |
||||
return -1; |
||||
} |
||||
#if defined(_WIN32) |
||||
*handle = _beginthreadex(NULL, 0, func, args, 0, NULL); |
||||
return *handle != 0 ? 0 : -1; |
||||
#else |
||||
return pthread_create(handle, NULL, func, args); |
||||
#endif |
||||
} |
||||
|
||||
int argon2_thread_join(argon2_thread_handle_t handle) { |
||||
#if defined(_WIN32) |
||||
if (WaitForSingleObject((HANDLE)handle, INFINITE) == WAIT_OBJECT_0) { |
||||
return CloseHandle((HANDLE)handle) != 0 ? 0 : -1; |
||||
} |
||||
return -1; |
||||
#else |
||||
return pthread_join(handle, NULL); |
||||
#endif |
||||
} |
||||
|
||||
void argon2_thread_exit(void) { |
||||
#if defined(_WIN32) |
||||
_endthreadex(0); |
||||
#else |
||||
pthread_exit(NULL); |
||||
#endif |
||||
} |
||||
|
||||
#endif /* ARGON2_NO_THREADS */ |
||||
@ -0,0 +1,67 @@
|
||||
/*
|
||||
* 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 : http://creativecommons.org/publicdomain/zero/1.0
|
||||
* - Apache 2.0 : http://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. |
||||
*/ |
||||
|
||||
#ifndef ARGON2_THREAD_H |
||||
#define ARGON2_THREAD_H |
||||
|
||||
#if !defined(ARGON2_NO_THREADS) |
||||
|
||||
/*
|
||||
Here we implement an abstraction layer for the simpĺe requirements |
||||
of the Argon2 code. We only require 3 primitives---thread creation, |
||||
joining, and termination---so full emulation of the pthreads API |
||||
is unwarranted. Currently we wrap pthreads and Win32 threads. |
||||
|
||||
The API defines 2 types: the function pointer type, |
||||
argon2_thread_func_t, |
||||
and the type of the thread handle---argon2_thread_handle_t. |
||||
*/ |
||||
#if defined(_WIN32) |
||||
#include <process.h> |
||||
typedef unsigned(__stdcall *argon2_thread_func_t)(void *); |
||||
typedef uintptr_t argon2_thread_handle_t; |
||||
#else |
||||
#include <pthread.h> |
||||
typedef void *(*argon2_thread_func_t)(void *); |
||||
typedef pthread_t argon2_thread_handle_t; |
||||
#endif |
||||
|
||||
/* Creates a thread
|
||||
* @param handle pointer to a thread handle, which is the output of this |
||||
* function. Must not be NULL. |
||||
* @param func A function pointer for the thread's entry point. Must not be |
||||
* NULL. |
||||
* @param args Pointer that is passed as an argument to @func. May be NULL. |
||||
* @return 0 if @handle and @func are valid pointers and a thread is successfully |
||||
* created. |
||||
*/ |
||||
int argon2_thread_create(argon2_thread_handle_t *handle, |
||||
argon2_thread_func_t func, void *args); |
||||
|
||||
/* Waits for a thread to terminate
|
||||
* @param handle Handle to a thread created with argon2_thread_create. |
||||
* @return 0 if @handle is a valid handle, and joining completed successfully. |
||||
*/ |
||||
int argon2_thread_join(argon2_thread_handle_t handle); |
||||
|
||||
/* Terminate the current thread. Must be run inside a thread created by
|
||||
* argon2_thread_create. |
||||
*/ |
||||
void argon2_thread_exit(void); |
||||
|
||||
#endif /* ARGON2_NO_THREADS */ |
||||
#endif |
||||
Loading…
Reference in new issue