253bf0cb8b
* Cleanup argon c files: * Remove encoded format and base64 encoder * Remove verification code * Remove all variants based simple caller * Add basic hashing function * Add a simple KAT test * Define more things at the haskell level
143 lines
4.0 KiB
C
143 lines
4.0 KiB
C
/*
|
|
* 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 "core.c"
|
|
|
|
int cryptonite_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;
|
|
|
|
/* 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 cryptonite_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, argon2_type type,
|
|
const uint32_t version){
|
|
|
|
argon2_context context;
|
|
int result;
|
|
uint8_t *out;
|
|
|
|
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 = cryptonite_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);
|
|
}
|
|
|
|
clear_internal_memory(out, hashlen);
|
|
free(out);
|
|
|
|
return ARGON2_OK;
|
|
}
|
|
|