mirror of https://github.com/tevador/RandomX
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
255 lines
9.3 KiB
255 lines
9.3 KiB
/*
|
|
Copyright (c) 2018-2019, tevador <tevador@gmail.com>
|
|
|
|
All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions are met:
|
|
* Redistributions of source code must retain the above copyright
|
|
notice, this list of conditions and the following disclaimer.
|
|
* Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
* Neither the name of the copyright holder nor the
|
|
names of its contributors may be used to endorse or promote products
|
|
derived from this software without specific prior written permission.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
|
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
/* Original code from Argon2 reference source code package used under CC0 Licence
|
|
* https://github.com/P-H-C/phc-winner-argon2
|
|
* Copyright 2015
|
|
* Daniel Dinu, Dmitry Khovratovich, Jean-Philippe Aumasson, and Samuel Neves
|
|
*/
|
|
|
|
#ifndef ARGON2_CORE_H
|
|
#define ARGON2_CORE_H
|
|
|
|
#include <stdint.h>
|
|
#include "argon2.h"
|
|
|
|
#if defined(__cplusplus)
|
|
extern "C" {
|
|
#endif
|
|
|
|
#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 rxa2_init_block_value(block *b, uint8_t in);
|
|
|
|
/* Copy block @src to block @dst */
|
|
void rxa2_copy_block(block *dst, const block *src);
|
|
|
|
/* XOR @src onto @dst bytewise */
|
|
void rxa2_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 rxa2_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 rxa2_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 rxa2_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 rxa2_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 rxa2_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 rxa2_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 rxa2_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 rxa2_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 rxa2_argon_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 rxa2_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 rxa2_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 rxa2_fill_memory_blocks(argon2_instance_t *instance);
|
|
|
|
#if defined(__cplusplus)
|
|
}
|
|
#endif
|
|
|
|
#endif
|