diff --git a/src/argon2_core.c b/src/argon2_core.c
index cf07be5..a028148 100644
--- a/src/argon2_core.c
+++ b/src/argon2_core.c
@@ -61,13 +61,13 @@ along with RandomX. If not, see.
#endif
/***************Instance and Position constructors**********/
-void init_block_value(block *b, uint8_t in) { memset(b->v, in, sizeof(b->v)); }
+void rxa2_init_block_value(block *b, uint8_t in) { memset(b->v, in, sizeof(b->v)); }
-void copy_block(block *dst, const block *src) {
+void rxa2_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) {
+void rxa2_xor_block(block *dst, const block *src) {
int i;
for (i = 0; i < ARGON2_QWORDS_IN_BLOCK; ++i) {
dst->v[i] ^= src->v[i];
@@ -90,7 +90,7 @@ static void store_block(void *output, const block *src) {
/***************Memory functions*****************/
-int allocate_memory(const argon2_context *context, uint8_t **memory,
+int rxa2_allocate_memory(const argon2_context *context, uint8_t **memory,
size_t num, size_t size) {
size_t memory_size = num * size;
if (memory == NULL) {
@@ -117,10 +117,10 @@ int allocate_memory(const argon2_context *context, uint8_t **memory,
return ARGON2_OK;
}
-void free_memory(const argon2_context *context, uint8_t *memory,
+void rxa2_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);
+ rxa2_clear_internal_memory(memory, memory_size);
if (context->free_cbk) {
(context->free_cbk)(memory, memory_size);
}
@@ -129,7 +129,7 @@ void free_memory(const argon2_context *context, uint8_t *memory,
}
}
-void NOT_OPTIMIZED secure_wipe_memory(void *v, size_t n) {
+void NOT_OPTIMIZED rxa2_secure_wipe_memory(void *v, size_t n) {
#if defined(_MSC_VER) && VC_GE_2005(_MSC_VER)
SecureZeroMemory(v, n);
#elif defined memset_s
@@ -144,13 +144,13 @@ void NOT_OPTIMIZED secure_wipe_memory(void *v, size_t n) {
/* Memory clear flag defaults to true. */
#define FLAG_clear_internal_memory 0
-void clear_internal_memory(void *v, size_t n) {
+void rxa2_clear_internal_memory(void *v, size_t n) {
if (FLAG_clear_internal_memory && v) {
- secure_wipe_memory(v, n);
+ rxa2_secure_wipe_memory(v, n);
}
}
-uint32_t index_alpha(const argon2_instance_t *instance,
+uint32_t rxa2_index_alpha(const argon2_instance_t *instance,
const argon2_position_t *position, uint32_t pseudo_rand,
int same_lane) {
/*
@@ -232,7 +232,7 @@ static int fill_memory_blocks_st(argon2_instance_t *instance) {
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);
+ rxa2_fill_segment(instance, position);
}
}
#ifdef GENKAT
@@ -242,14 +242,14 @@ static int fill_memory_blocks_st(argon2_instance_t *instance) {
return ARGON2_OK;
}
-int fill_memory_blocks(argon2_instance_t *instance) {
+int rxa2_fill_memory_blocks(argon2_instance_t *instance) {
if (instance == NULL || instance->lanes == 0) {
return ARGON2_INCORRECT_PARAMETER;
}
return fill_memory_blocks_st(instance);
}
-int validate_inputs(const argon2_context *context) {
+int rxa2_validate_inputs(const argon2_context *context) {
if (NULL == context) {
return ARGON2_INCORRECT_PARAMETER;
}
@@ -378,7 +378,7 @@ int validate_inputs(const argon2_context *context) {
return ARGON2_OK;
}
-void fill_first_blocks(uint8_t *blockhash, const argon2_instance_t *instance) {
+void rxa2_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) */
@@ -387,21 +387,21 @@ void fill_first_blocks(uint8_t *blockhash, const argon2_instance_t *instance) {
store32(blockhash + ARGON2_PREHASH_DIGEST_LENGTH, 0);
store32(blockhash + ARGON2_PREHASH_DIGEST_LENGTH + 4, l);
- blake2b_long(blockhash_bytes, ARGON2_BLOCK_SIZE, blockhash,
+ rxa2_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,
+ rxa2_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);
+ rxa2_clear_internal_memory(blockhash_bytes, ARGON2_BLOCK_SIZE);
}
-void initial_hash(uint8_t *blockhash, argon2_context *context, argon2_type type) {
+void rxa2_initial_hash(uint8_t *blockhash, argon2_context *context, argon2_type type) {
blake2b_state BlakeHash;
uint8_t value[sizeof(uint32_t)];
@@ -437,7 +437,7 @@ void initial_hash(uint8_t *blockhash, argon2_context *context, argon2_type type)
context->pwdlen);
if (context->flags & ARGON2_FLAG_CLEAR_PASSWORD) {
- secure_wipe_memory(context->pwd, context->pwdlen);
+ rxa2_secure_wipe_memory(context->pwd, context->pwdlen);
context->pwdlen = 0;
}
}
@@ -457,7 +457,7 @@ void initial_hash(uint8_t *blockhash, argon2_context *context, argon2_type type)
context->secretlen);
if (context->flags & ARGON2_FLAG_CLEAR_SECRET) {
- secure_wipe_memory(context->secret, context->secretlen);
+ rxa2_secure_wipe_memory(context->secret, context->secretlen);
context->secretlen = 0;
}
}
@@ -473,7 +473,7 @@ void initial_hash(uint8_t *blockhash, argon2_context *context, argon2_type type)
blake2b_final(&BlakeHash, blockhash, ARGON2_PREHASH_DIGEST_LENGTH);
}
-int argon_initialize(argon2_instance_t *instance, argon2_context *context) {
+int rxa2_argon_initialize(argon2_instance_t *instance, argon2_context *context) {
uint8_t blockhash[ARGON2_PREHASH_SEED_LENGTH];
int result = ARGON2_OK;
@@ -491,17 +491,17 @@ int argon_initialize(argon2_instance_t *instance, argon2_context *context) {
/* 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);
+ rxa2_initial_hash(blockhash, context, instance->type);
/* Zeroing 8 extra bytes */
- clear_internal_memory(blockhash + ARGON2_PREHASH_DIGEST_LENGTH,
+ rxa2_clear_internal_memory(blockhash + ARGON2_PREHASH_DIGEST_LENGTH,
ARGON2_PREHASH_SEED_LENGTH -
ARGON2_PREHASH_DIGEST_LENGTH);
/* 3. Creating first blocks, we always have at least two blocks in a slice
*/
- fill_first_blocks(blockhash, instance);
+ rxa2_fill_first_blocks(blockhash, instance);
/* Clearing the hash */
- clear_internal_memory(blockhash, ARGON2_PREHASH_SEED_LENGTH);
+ rxa2_clear_internal_memory(blockhash, ARGON2_PREHASH_SEED_LENGTH);
return ARGON2_OK;
}
diff --git a/src/argon2_core.h b/src/argon2_core.h
index 69a6339..3fd3122 100644
--- a/src/argon2_core.h
+++ b/src/argon2_core.h
@@ -67,13 +67,13 @@ 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);
+void rxa2_init_block_value(block *b, uint8_t in);
/* Copy block @src to block @dst */
-void copy_block(block *dst, const block *src);
+void rxa2_copy_block(block *dst, const block *src);
/* XOR @src onto @dst bytewise */
-void xor_block(block *dst, const block *src);
+void rxa2_xor_block(block *dst, const block *src);
/*
* Argon2 instance: memory pointer, number of passes, amount of memory, type,
@@ -122,7 +122,7 @@ typedef struct Argon2_thread_data {
* @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,
+int rxa2_allocate_memory(const argon2_context *context, uint8_t **memory,
size_t num, size_t size);
/*
@@ -133,7 +133,7 @@ int allocate_memory(const argon2_context *context, uint8_t **memory,
* @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,
+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
@@ -141,14 +141,14 @@ void free_memory(const argon2_context *context, uint8_t *memory,
* @param mem Pointer to the memory
* @param s Memory size in bytes
*/
-void secure_wipe_memory(void *v, size_t n);
+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 clear_internal_memory(void *v, size_t n);
+void rxa2_clear_internal_memory(void *v, size_t n);
/*
* Computes absolute position of reference block in the lane following a skewed
@@ -160,7 +160,7 @@ void clear_internal_memory(void *v, size_t n);
* If so we can reference the current segment
* @pre All pointers must be valid
*/
-uint32_t index_alpha(const argon2_instance_t *instance,
+uint32_t rxa2_index_alpha(const argon2_instance_t *instance,
const argon2_position_t *position, uint32_t pseudo_rand,
int same_lane);
@@ -171,7 +171,7 @@ uint32_t index_alpha(const argon2_instance_t *instance,
* @return ARGON2_OK if everything is all right, otherwise one of error codes
* (all defined in
*/
-int validate_inputs(const argon2_context *context);
+int rxa2_validate_inputs(const argon2_context *context);
/*
* Hashes all the inputs into @a blockhash[PREHASH_DIGEST_LENGTH], clears
@@ -183,7 +183,7 @@ int validate_inputs(const argon2_context *context);
* @pre @a blockhash must have at least @a PREHASH_DIGEST_LENGTH bytes
* allocated
*/
-void initial_hash(uint8_t *blockhash, argon2_context *context,
+void rxa2_initial_hash(uint8_t *blockhash, argon2_context *context,
argon2_type type);
/*
@@ -192,7 +192,7 @@ void initial_hash(uint8_t *blockhash, argon2_context *context,
* @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);
+void rxa2_fill_first_blocks(uint8_t *blockhash, const argon2_instance_t *instance);
/*
* Function allocates memory, hashes the inputs with Blake, and creates first
@@ -204,7 +204,7 @@ void fill_first_blocks(uint8_t *blockhash, const argon2_instance_t *instance);
* @return Zero if successful, -1 if memory failed to allocate. @context->state
* will be modified if successful.
*/
-int argon_initialize(argon2_instance_t *instance, argon2_context *context);
+int rxa2_argon_initialize(argon2_instance_t *instance, argon2_context *context);
/*
* XORing the last block of each lane, hashing it, making the tag. Deallocates
@@ -217,7 +217,7 @@ int argon_initialize(argon2_instance_t *instance, argon2_context *context);
* @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);
+void rxa2_finalize(const argon2_context *context, argon2_instance_t *instance);
/*
* Function that fills the segment using previous segments also from other
@@ -227,7 +227,7 @@ void finalize(const argon2_context *context, argon2_instance_t *instance);
* @param position Current position
* @pre all block pointers must be valid
*/
-void fill_segment(const argon2_instance_t *instance,
+void rxa2_fill_segment(const argon2_instance_t *instance,
argon2_position_t position);
/*
@@ -236,7 +236,7 @@ void fill_segment(const argon2_instance_t *instance,
* @param instance Pointer to the current instance
* @return ARGON2_OK if successful, @context->state
*/
-int fill_memory_blocks(argon2_instance_t *instance);
+int rxa2_fill_memory_blocks(argon2_instance_t *instance);
#if defined(__cplusplus)
}
diff --git a/src/argon2_ref.c b/src/argon2_ref.c
index f35f8e3..8a4eecc 100644
--- a/src/argon2_ref.c
+++ b/src/argon2_ref.c
@@ -48,13 +48,13 @@ static void fill_block(const block *prev_block, const block *ref_block,
block blockR, block_tmp;
unsigned i;
- copy_block(&blockR, ref_block);
- xor_block(&blockR, prev_block);
- copy_block(&block_tmp, &blockR);
+ rxa2_copy_block(&blockR, ref_block);
+ rxa2_xor_block(&blockR, prev_block);
+ rxa2_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);
+ rxa2_xor_block(&block_tmp, next_block);
/* Now blockR = ref_block + prev_block and
block_tmp = ref_block + prev_block + next_block */
}
@@ -83,8 +83,8 @@ static void fill_block(const block *prev_block, const block *ref_block,
blockR.v[2 * i + 113]);
}
- copy_block(next_block, &block_tmp);
- xor_block(next_block, &blockR);
+ rxa2_copy_block(next_block, &block_tmp);
+ rxa2_xor_block(next_block, &blockR);
}
static void next_addresses(block *address_block, block *input_block,
@@ -94,7 +94,7 @@ static void next_addresses(block *address_block, block *input_block,
fill_block(zero_block, address_block, address_block, 0);
}
-void fill_segment(const argon2_instance_t *instance,
+void rxa2_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;
@@ -114,8 +114,8 @@ void fill_segment(const argon2_instance_t *instance,
(position.slice < ARGON2_SYNC_POINTS / 2));
if (data_independent_addressing) {
- init_block_value(&zero_block, 0);
- init_block_value(&input_block, 0);
+ rxa2_init_block_value(&zero_block, 0);
+ rxa2_init_block_value(&input_block, 0);
input_block.v[0] = position.pass;
input_block.v[1] = position.lane;
@@ -180,7 +180,7 @@ void fill_segment(const argon2_instance_t *instance,
* lane.
*/
position.index = i;
- ref_index = index_alpha(instance, &position, pseudo_rand & 0xFFFFFFFF,
+ ref_index = rxa2_index_alpha(instance, &position, pseudo_rand & 0xFFFFFFFF,
ref_lane == position.lane);
/* 2 Creating a new block */
diff --git a/src/blake2/blake2.h b/src/blake2/blake2.h
index e099731..277077b 100644
--- a/src/blake2/blake2.h
+++ b/src/blake2/blake2.h
@@ -88,7 +88,7 @@ extern "C" {
const void *key, size_t keylen);
/* Argon2 Team - Begin Code */
- int blake2b_long(void *out, size_t outlen, const void *in, size_t inlen);
+ int rxa2_blake2b_long(void *out, size_t outlen, const void *in, size_t inlen);
/* Argon2 Team - End Code */
#if defined(__cplusplus)
diff --git a/src/blake2/blake2b.c b/src/blake2/blake2b.c
index 329ed3c..ece254f 100644
--- a/src/blake2/blake2b.c
+++ b/src/blake2/blake2b.c
@@ -338,7 +338,7 @@ fail:
}
/* Argon2 Team - Begin Code */
-int blake2b_long(void *pout, size_t outlen, const void *in, size_t inlen) {
+int rxa2_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 };
diff --git a/src/dataset.cpp b/src/dataset.cpp
index 210589d..8aa6511 100644
--- a/src/dataset.cpp
+++ b/src/dataset.cpp
@@ -95,9 +95,9 @@ namespace randomx {
/* 3. Initialization: Hashing inputs, allocating memory, filling first
* blocks
*/
- argon_initialize(&instance, &context);
+ rxa2_argon_initialize(&instance, &context);
- fill_memory_blocks(&instance);
+ rxa2_fill_memory_blocks(&instance);
cache->reciprocalCache.clear();
randomx::Blake2Generator gen(key, keySize);