mirror of
https://github.com/LBRYFoundation/pool.git
synced 2025-08-23 17:37:25 +00:00
Add lyra2v2 algo
This commit is contained in:
Tanguy Pruvot
parent
a42a33c524
commit
4a2ec5a9fd
15 changed files with 559 additions and 815 deletions
2
rc.local
2
rc.local
|
|
@ -19,7 +19,6 @@ screen -dmS debug tail -f $LOG_DIR/debug.log
|
|||
|
||||
# Stratum ports
|
||||
|
||||
screen -dmS bmw $STRATUM_DIR/run.sh bmw
|
||||
screen -dmS c11 $STRATUM_DIR/run.sh c11
|
||||
screen -dmS x11 $STRATUM_DIR/run.sh x11
|
||||
screen -dmS x13 $STRATUM_DIR/run.sh x13
|
||||
|
|
@ -32,6 +31,7 @@ screen -dmS quark $STRATUM_DIR/run.sh quark
|
|||
screen -dmS qubit $STRATUM_DIR/run.sh qubit
|
||||
#screen -dmS groestl $STRATUM_DIR/run.sh groestl # dmd-gr -m 256
|
||||
screen -dmS lyra2 $STRATUM_DIR/run.sh lyra2
|
||||
screen -dmS lyra2v2 $STRATUM_DIR/run.sh lyra2v2
|
||||
|
||||
screen -dmS skein $STRATUM_DIR/run.sh skein
|
||||
screen -dmS skein2 $STRATUM_DIR/run.sh skein2
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@
|
|||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
|
||||
#include "Lyra2.h"
|
||||
#include "Sponge.h"
|
||||
|
||||
|
|
@ -43,166 +44,171 @@
|
|||
*
|
||||
* @return 0 if the key is generated correctly; -1 if there is an error (usually due to lack of memory for allocation)
|
||||
*/
|
||||
int LYRA2(void *K, uint64_t kLen, const void *pwd, uint64_t pwdlen, const void *salt, uint64_t saltlen, uint64_t timeCost, uint64_t nRows, uint64_t nCols) {
|
||||
int LYRA2(void *K, int64_t kLen, const void *pwd, int32_t pwdlen, const void *salt, int32_t saltlen, int64_t timeCost, const int16_t nRows, const int16_t nCols)
|
||||
{
|
||||
//============================= Basic variables ============================//
|
||||
int64_t row = 2; //index of row to be processed
|
||||
int64_t prev = 1; //index of prev (last row ever computed/modified)
|
||||
int64_t rowa = 0; //index of row* (a previous row, deterministically picked during Setup and randomly picked while Wandering)
|
||||
int64_t tau; //Time Loop iterator
|
||||
int64_t step = 1; //Visitation step (used during Setup and Wandering phases)
|
||||
int64_t window = 2; //Visitation window (used to define which rows can be revisited during Setup)
|
||||
int64_t gap = 1; //Modifier to the step, assuming the values 1 or -1
|
||||
int64_t i; //auxiliary iteration counter
|
||||
int64_t v64; // 64bit var for memcpy
|
||||
//==========================================================================/
|
||||
|
||||
//============================= Basic variables ============================//
|
||||
int64_t row = 2; //index of row to be processed
|
||||
int64_t prev = 1; //index of prev (last row ever computed/modified)
|
||||
int64_t rowa = 0; //index of row* (a previous row, deterministically picked during Setup and randomly picked while Wandering)
|
||||
int64_t tau; //Time Loop iterator
|
||||
int64_t step = 1; //Visitation step (used during Setup and Wandering phases)
|
||||
int64_t window = 2; //Visitation window (used to define which rows can be revisited during Setup)
|
||||
int64_t gap = 1; //Modifier to the step, assuming the values 1 or -1
|
||||
int64_t i; //auxiliary iteration counter
|
||||
//==========================================================================/
|
||||
//========== Initializing the Memory Matrix and pointers to it =============//
|
||||
//Tries to allocate enough space for the whole memory matrix
|
||||
|
||||
//========== Initializing the Memory Matrix and pointers to it =============//
|
||||
//Tries to allocate enough space for the whole memory matrix
|
||||
i = (int64_t) ((int64_t) nRows * (int64_t) ROW_LEN_BYTES);
|
||||
uint64_t *wholeMatrix = malloc(i);
|
||||
if (wholeMatrix == NULL) {
|
||||
return -1;
|
||||
}
|
||||
const int64_t ROW_LEN_INT64 = BLOCK_LEN_INT64 * nCols;
|
||||
const int64_t ROW_LEN_BYTES = ROW_LEN_INT64 * 8;
|
||||
// for Lyra2REv2, nCols = 4, v1 was using 8
|
||||
const int64_t BLOCK_LEN = (nCols == 4) ? BLOCK_LEN_BLAKE2_SAFE_INT64 : BLOCK_LEN_BLAKE2_SAFE_BYTES;
|
||||
|
||||
i = (int64_t)ROW_LEN_BYTES * nRows;
|
||||
uint64_t *wholeMatrix = malloc(i);
|
||||
if (wholeMatrix == NULL) {
|
||||
return -1;
|
||||
}
|
||||
memset(wholeMatrix, 0, i);
|
||||
|
||||
//Allocates pointers to each row of the matrix
|
||||
uint64_t **memMatrix = malloc(nRows * sizeof (uint64_t*));
|
||||
if (memMatrix == NULL) {
|
||||
return -1;
|
||||
}
|
||||
//Places the pointers in the correct positions
|
||||
uint64_t *ptrWord = wholeMatrix;
|
||||
for (i = 0; i < nRows; i++) {
|
||||
memMatrix[i] = ptrWord;
|
||||
ptrWord += ROW_LEN_INT64;
|
||||
}
|
||||
//==========================================================================/
|
||||
//Allocates pointers to each row of the matrix
|
||||
uint64_t **memMatrix = malloc(sizeof(uint64_t*) * nRows);
|
||||
if (memMatrix == NULL) {
|
||||
return -1;
|
||||
}
|
||||
//Places the pointers in the correct positions
|
||||
uint64_t *ptrWord = wholeMatrix;
|
||||
for (i = 0; i < nRows; i++) {
|
||||
memMatrix[i] = ptrWord;
|
||||
ptrWord += ROW_LEN_INT64;
|
||||
}
|
||||
//==========================================================================/
|
||||
|
||||
//============= Getting the password + salt + basil padded with 10*1 ===============//
|
||||
//OBS.:The memory matrix will temporarily hold the password: not for saving memory,
|
||||
//but this ensures that the password copied locally will be overwritten as soon as possible
|
||||
//============= Getting the password + salt + basil padded with 10*1 ===============//
|
||||
//OBS.:The memory matrix will temporarily hold the password: not for saving memory,
|
||||
//but this ensures that the password copied locally will be overwritten as soon as possible
|
||||
|
||||
//First, we clean enough blocks for the password, salt, basil and padding
|
||||
uint64_t nBlocksInput = ((saltlen + pwdlen + 6 * sizeof (uint64_t)) / BLOCK_LEN_BLAKE2_SAFE_BYTES) + 1;
|
||||
byte *ptrByte = (byte*) wholeMatrix;
|
||||
memset(ptrByte, 0, nBlocksInput * BLOCK_LEN_BLAKE2_SAFE_BYTES);
|
||||
//First, we clean enough blocks for the password, salt, basil and padding
|
||||
int64_t nBlocksInput = ((saltlen + pwdlen + 6 * sizeof(uint64_t)) / BLOCK_LEN_BLAKE2_SAFE_BYTES) + 1;
|
||||
|
||||
//Prepends the password
|
||||
memcpy(ptrByte, pwd, pwdlen);
|
||||
ptrByte += pwdlen;
|
||||
byte *ptrByte = (byte*) wholeMatrix;
|
||||
|
||||
//Concatenates the salt
|
||||
memcpy(ptrByte, salt, saltlen);
|
||||
ptrByte += saltlen;
|
||||
//Prepends the password
|
||||
memcpy(ptrByte, pwd, pwdlen);
|
||||
ptrByte += pwdlen;
|
||||
|
||||
//Concatenates the basil: every integer passed as parameter, in the order they are provided by the interface
|
||||
memcpy(ptrByte, &kLen, sizeof (uint64_t));
|
||||
ptrByte += sizeof (uint64_t);
|
||||
memcpy(ptrByte, &pwdlen, sizeof (uint64_t));
|
||||
ptrByte += sizeof (uint64_t);
|
||||
memcpy(ptrByte, &saltlen, sizeof (uint64_t));
|
||||
ptrByte += sizeof (uint64_t);
|
||||
memcpy(ptrByte, &timeCost, sizeof (uint64_t));
|
||||
ptrByte += sizeof (uint64_t);
|
||||
memcpy(ptrByte, &nRows, sizeof (uint64_t));
|
||||
ptrByte += sizeof (uint64_t);
|
||||
memcpy(ptrByte, &nCols, sizeof (uint64_t));
|
||||
ptrByte += sizeof (uint64_t);
|
||||
//Concatenates the salt
|
||||
memcpy(ptrByte, salt, saltlen);
|
||||
ptrByte += saltlen;
|
||||
|
||||
//Now comes the padding
|
||||
*ptrByte = 0x80; //first byte of padding: right after the password
|
||||
ptrByte = (byte*) wholeMatrix; //resets the pointer to the start of the memory matrix
|
||||
ptrByte += nBlocksInput * BLOCK_LEN_BLAKE2_SAFE_BYTES - 1; //sets the pointer to the correct position: end of incomplete block
|
||||
*ptrByte ^= 0x01; //last byte of padding: at the end of the last incomplete block
|
||||
//==========================================================================/
|
||||
memset(ptrByte, 0, nBlocksInput * BLOCK_LEN_BLAKE2_SAFE_BYTES - (saltlen + pwdlen));
|
||||
|
||||
//======================= Initializing the Sponge State ====================//
|
||||
//Sponge state: 16 uint64_t, BLOCK_LEN_INT64 words of them for the bitrate (b) and the remainder for the capacity (c)
|
||||
uint64_t *state = malloc(16 * sizeof (uint64_t));
|
||||
if (state == NULL) {
|
||||
return -1;
|
||||
}
|
||||
initState(state);
|
||||
//==========================================================================/
|
||||
//Concatenates the basil: every integer passed as parameter, in the order they are provided by the interface
|
||||
memcpy(ptrByte, &kLen, sizeof(int64_t));
|
||||
ptrByte += sizeof(uint64_t);
|
||||
v64 = pwdlen;
|
||||
memcpy(ptrByte, &v64, sizeof(int64_t));
|
||||
ptrByte += sizeof(uint64_t);
|
||||
v64 = saltlen;
|
||||
memcpy(ptrByte, &v64, sizeof(int64_t));
|
||||
ptrByte += sizeof(uint64_t);
|
||||
v64 = timeCost;
|
||||
memcpy(ptrByte, &v64, sizeof(int64_t));
|
||||
ptrByte += sizeof(uint64_t);
|
||||
v64 = nRows;
|
||||
memcpy(ptrByte, &v64, sizeof(int64_t));
|
||||
ptrByte += sizeof(uint64_t);
|
||||
v64 = nCols;
|
||||
memcpy(ptrByte, &v64, sizeof(int64_t));
|
||||
ptrByte += sizeof(uint64_t);
|
||||
|
||||
//================================ Setup Phase =============================//
|
||||
//Absorbing salt, password and basil: this is the only place in which the block length is hard-coded to 512 bits
|
||||
ptrWord = wholeMatrix;
|
||||
for (i = 0; i < nBlocksInput; i++) {
|
||||
absorbBlockBlake2Safe(state, ptrWord); //absorbs each block of pad(pwd || salt || basil)
|
||||
ptrWord += BLOCK_LEN_BLAKE2_SAFE_BYTES; //goes to next block of pad(pwd || salt || basil)
|
||||
}
|
||||
//Now comes the padding
|
||||
*ptrByte = 0x80; //first byte of padding: right after the password
|
||||
ptrByte = (byte*) wholeMatrix; //resets the pointer to the start of the memory matrix
|
||||
ptrByte += nBlocksInput * BLOCK_LEN_BLAKE2_SAFE_BYTES - 1; //sets the pointer to the correct position: end of incomplete block
|
||||
*ptrByte ^= 0x01; //last byte of padding: at the end of the last incomplete block
|
||||
//==========================================================================/
|
||||
|
||||
//Initializes M[0] and M[1]
|
||||
reducedSqueezeRow0(state, memMatrix[0]); //The locally copied password is most likely overwritten here
|
||||
reducedDuplexRow1(state, memMatrix[0], memMatrix[1]);
|
||||
//======================= Initializing the Sponge State ====================//
|
||||
//Sponge state: 16 uint64_t, BLOCK_LEN_INT64 words of them for the bitrate (b) and the remainder for the capacity (c)
|
||||
uint64_t state[16];
|
||||
initState(state);
|
||||
//==========================================================================/
|
||||
|
||||
do {
|
||||
//M[row] = rand; //M[row*] = M[row*] XOR rotW(rand)
|
||||
reducedDuplexRowSetup(state, memMatrix[prev], memMatrix[rowa], memMatrix[row]);
|
||||
//================================ Setup Phase =============================//
|
||||
//Absorbing salt, password and basil: this is the only place in which the block length is hard-coded to 512 bits
|
||||
ptrWord = wholeMatrix;
|
||||
for (i = 0; i < nBlocksInput; i++) {
|
||||
absorbBlockBlake2Safe(state, ptrWord); //absorbs each block of pad(pwd || salt || basil)
|
||||
ptrWord += BLOCK_LEN; //goes to next block of pad(pwd || salt || basil)
|
||||
}
|
||||
|
||||
//Initializes M[0] and M[1]
|
||||
reducedSqueezeRow0(state, memMatrix[0], nCols); //The locally copied password is most likely overwritten here
|
||||
|
||||
//updates the value of row* (deterministically picked during Setup))
|
||||
rowa = (rowa + step) & (window - 1);
|
||||
//update prev: it now points to the last row ever computed
|
||||
prev = row;
|
||||
//updates row: goes to the next row to be computed
|
||||
row++;
|
||||
reducedDuplexRow1(state, memMatrix[0], memMatrix[1], nCols);
|
||||
|
||||
//Checks if all rows in the window where visited.
|
||||
if (rowa == 0) {
|
||||
step = window + gap; //changes the step: approximately doubles its value
|
||||
window *= 2; //doubles the size of the re-visitation window
|
||||
gap = -gap; //inverts the modifier to the step
|
||||
}
|
||||
do {
|
||||
//M[row] = rand; //M[row*] = M[row*] XOR rotW(rand)
|
||||
|
||||
} while (row < nRows);
|
||||
//==========================================================================/
|
||||
reducedDuplexRowSetup(state, memMatrix[prev], memMatrix[rowa], memMatrix[row], nCols);
|
||||
|
||||
//============================ Wandering Phase =============================//
|
||||
row = 0; //Resets the visitation to the first row of the memory matrix
|
||||
for (tau = 1; tau <= timeCost; tau++) {
|
||||
//Step is approximately half the number of all rows of the memory matrix for an odd tau; otherwise, it is -1
|
||||
step = (tau % 2 == 0) ? -1 : nRows / 2 - 1;
|
||||
do {
|
||||
//Selects a pseudorandom index row*
|
||||
//------------------------------------------------------------------------------------------
|
||||
//rowa = ((unsigned int)state[0]) & (nRows-1); //(USE THIS IF nRows IS A POWER OF 2)
|
||||
rowa = ((uint64_t) (state[0])) % nRows; //(USE THIS FOR THE "GENERIC" CASE)
|
||||
//------------------------------------------------------------------------------------------
|
||||
//updates the value of row* (deterministically picked during Setup))
|
||||
rowa = (rowa + step) & (window - 1);
|
||||
//update prev: it now points to the last row ever computed
|
||||
prev = row;
|
||||
//updates row: goes to the next row to be computed
|
||||
row++;
|
||||
|
||||
//Performs a reduced-round duplexing operation over M[row*] XOR M[prev], updating both M[row*] and M[row]
|
||||
reducedDuplexRow(state, memMatrix[prev], memMatrix[rowa], memMatrix[row]);
|
||||
//Checks if all rows in the window where visited.
|
||||
if (rowa == 0) {
|
||||
step = window + gap; //changes the step: approximately doubles its value
|
||||
window *= 2; //doubles the size of the re-visitation window
|
||||
gap = -gap; //inverts the modifier to the step
|
||||
}
|
||||
|
||||
//update prev: it now points to the last row ever computed
|
||||
prev = row;
|
||||
} while (row < nRows);
|
||||
//==========================================================================/
|
||||
|
||||
//updates row: goes to the next row to be computed
|
||||
//------------------------------------------------------------------------------------------
|
||||
//row = (row + step) & (nRows-1); //(USE THIS IF nRows IS A POWER OF 2)
|
||||
row = (row + step) % nRows; //(USE THIS FOR THE "GENERIC" CASE)
|
||||
//------------------------------------------------------------------------------------------
|
||||
//============================ Wandering Phase =============================//
|
||||
row = 0; //Resets the visitation to the first row of the memory matrix
|
||||
for (tau = 1; tau <= timeCost; tau++) {
|
||||
//Step is approximately half the number of all rows of the memory matrix for an odd tau; otherwise, it is -1
|
||||
step = (tau % 2 == 0) ? -1 : nRows / 2 - 1;
|
||||
do {
|
||||
//Selects a pseudorandom index row*
|
||||
//------------------------------------------------------------------------------------------
|
||||
rowa = state[0] & (unsigned int)(nRows-1); //(USE THIS IF nRows IS A POWER OF 2)
|
||||
//rowa = state[0] % nRows; //(USE THIS FOR THE "GENERIC" CASE)
|
||||
//------------------------------------------------------------------------------------------
|
||||
|
||||
} while (row != 0);
|
||||
}
|
||||
//==========================================================================/
|
||||
//Performs a reduced-round duplexing operation over M[row*] XOR M[prev], updating both M[row*] and M[row]
|
||||
reducedDuplexRow(state, memMatrix[prev], memMatrix[rowa], memMatrix[row], nCols);
|
||||
|
||||
//============================ Wrap-up Phase ===============================//
|
||||
//Absorbs the last block of the memory matrix
|
||||
absorbBlock(state, memMatrix[rowa]);
|
||||
//update prev: it now points to the last row ever computed
|
||||
prev = row;
|
||||
|
||||
//Squeezes the key
|
||||
squeeze(state, K, kLen);
|
||||
//==========================================================================/
|
||||
//updates row: goes to the next row to be computed
|
||||
//------------------------------------------------------------------------------------------
|
||||
row = (row + step) & (unsigned int)(nRows-1); //(USE THIS IF nRows IS A POWER OF 2)
|
||||
//row = (row + step) % nRows; //(USE THIS FOR THE "GENERIC" CASE)
|
||||
//------------------------------------------------------------------------------------------
|
||||
|
||||
//========================= Freeing the memory =============================//
|
||||
free(memMatrix);
|
||||
free(wholeMatrix);
|
||||
} while (row != 0);
|
||||
}
|
||||
|
||||
//Wiping out the sponge's internal state before freeing it
|
||||
memset(state, 0, 16 * sizeof (uint64_t));
|
||||
free(state);
|
||||
//==========================================================================/
|
||||
//============================ Wrap-up Phase ===============================//
|
||||
//Absorbs the last block of the memory matrix
|
||||
absorbBlock(state, memMatrix[rowa]);
|
||||
|
||||
return 0;
|
||||
//Squeezes the key
|
||||
squeeze(state, K, (unsigned int) kLen);
|
||||
|
||||
//========================= Freeing the memory =============================//
|
||||
free(memMatrix);
|
||||
free(wholeMatrix);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -37,14 +37,6 @@ typedef unsigned char byte;
|
|||
#define BLOCK_LEN_BYTES (BLOCK_LEN_INT64 * 8) //Block length, in bytes
|
||||
#endif
|
||||
|
||||
#ifndef N_COLS
|
||||
#define N_COLS 8 //Number of columns in the memory matrix: fixed to 64 by default
|
||||
#endif
|
||||
|
||||
#define ROW_LEN_INT64 (BLOCK_LEN_INT64 * N_COLS) //Total length of a row: N_COLS blocks
|
||||
#define ROW_LEN_BYTES (ROW_LEN_INT64 * 8) //Number of bytes per row
|
||||
|
||||
|
||||
int LYRA2(void *K, uint64_t kLen, const void *pwd, uint64_t pwdlen, const void *salt, uint64_t saltlen, uint64_t timeCost, uint64_t nRows, uint64_t nCols);
|
||||
int LYRA2(void *K, int64_t kLen, const void *pwd, int32_t pwdlen, const void *salt, int32_t saltlen, int64_t timeCost, const int16_t nRows, const int16_t nCols);
|
||||
|
||||
#endif /* LYRA2_H_ */
|
||||
|
|
|
|||
|
|
@ -25,7 +25,6 @@
|
|||
#include "Lyra2.h"
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Initializes the Sponge State. The first 512 bits are set to zeros and the remainder
|
||||
* receive Blake2b's IV as per Blake2b's specification. <b>Note:</b> Even though sponges
|
||||
|
|
@ -37,18 +36,18 @@
|
|||
*
|
||||
* @param state The 1024-bit array to be initialized
|
||||
*/
|
||||
inline void initState(uint64_t state[/*16*/]) {
|
||||
//First 512 bis are zeros
|
||||
memset(state, 0, 64);
|
||||
//Remainder BLOCK_LEN_BLAKE2_SAFE_BYTES are reserved to the IV
|
||||
state[8] = blake2b_IV[0];
|
||||
state[9] = blake2b_IV[1];
|
||||
state[10] = blake2b_IV[2];
|
||||
state[11] = blake2b_IV[3];
|
||||
state[12] = blake2b_IV[4];
|
||||
state[13] = blake2b_IV[5];
|
||||
state[14] = blake2b_IV[6];
|
||||
state[15] = blake2b_IV[7];
|
||||
void initState(uint64_t state[/*16*/]) {
|
||||
//First 512 bis are zeros
|
||||
memset(state, 0, 64);
|
||||
//Remainder BLOCK_LEN_BLAKE2_SAFE_BYTES are reserved to the IV
|
||||
state[8] = blake2b_IV[0];
|
||||
state[9] = blake2b_IV[1];
|
||||
state[10] = blake2b_IV[2];
|
||||
state[11] = blake2b_IV[3];
|
||||
state[12] = blake2b_IV[4];
|
||||
state[13] = blake2b_IV[5];
|
||||
state[14] = blake2b_IV[6];
|
||||
state[15] = blake2b_IV[7];
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -56,27 +55,27 @@ inline void initState(uint64_t state[/*16*/]) {
|
|||
*
|
||||
* @param v A 1024-bit (16 uint64_t) array to be processed by Blake2b's G function
|
||||
*/
|
||||
inline static void blake2bLyra(uint64_t *v) {
|
||||
ROUND_LYRA(0);
|
||||
ROUND_LYRA(1);
|
||||
ROUND_LYRA(2);
|
||||
ROUND_LYRA(3);
|
||||
ROUND_LYRA(4);
|
||||
ROUND_LYRA(5);
|
||||
ROUND_LYRA(6);
|
||||
ROUND_LYRA(7);
|
||||
ROUND_LYRA(8);
|
||||
ROUND_LYRA(9);
|
||||
ROUND_LYRA(10);
|
||||
ROUND_LYRA(11);
|
||||
__inline static void blake2bLyra(uint64_t *v) {
|
||||
ROUND_LYRA(0);
|
||||
ROUND_LYRA(1);
|
||||
ROUND_LYRA(2);
|
||||
ROUND_LYRA(3);
|
||||
ROUND_LYRA(4);
|
||||
ROUND_LYRA(5);
|
||||
ROUND_LYRA(6);
|
||||
ROUND_LYRA(7);
|
||||
ROUND_LYRA(8);
|
||||
ROUND_LYRA(9);
|
||||
ROUND_LYRA(10);
|
||||
ROUND_LYRA(11);
|
||||
}
|
||||
|
||||
/**
|
||||
* Executes a reduced version of Blake2b's G function with only one round
|
||||
* @param v A 1024-bit (16 uint64_t) array to be processed by Blake2b's G function
|
||||
*/
|
||||
inline static void reducedBlake2bLyra(uint64_t *v) {
|
||||
ROUND_LYRA(0);
|
||||
__inline static void reducedBlake2bLyra(uint64_t *v) {
|
||||
ROUND_LYRA(0);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -87,19 +86,20 @@ inline static void reducedBlake2bLyra(uint64_t *v) {
|
|||
* @param out Array that will receive the data squeezed
|
||||
* @param len The number of bytes to be squeezed into the "out" array
|
||||
*/
|
||||
inline void squeeze(uint64_t *state, byte *out, unsigned int len) {
|
||||
int fullBlocks = len / BLOCK_LEN_BYTES;
|
||||
byte *ptr = out;
|
||||
int i;
|
||||
//Squeezes full blocks
|
||||
for (i = 0; i < fullBlocks; i++) {
|
||||
memcpy(ptr, state, BLOCK_LEN_BYTES);
|
||||
blake2bLyra(state);
|
||||
ptr += BLOCK_LEN_BYTES;
|
||||
}
|
||||
void squeeze(uint64_t *state, byte *out, unsigned int len)
|
||||
{
|
||||
int fullBlocks = len / BLOCK_LEN_BYTES;
|
||||
byte *ptr = out;
|
||||
int i;
|
||||
//Squeezes full blocks
|
||||
for (i = 0; i < fullBlocks; i++) {
|
||||
memcpy(ptr, state, BLOCK_LEN_BYTES);
|
||||
blake2bLyra(state);
|
||||
ptr += BLOCK_LEN_BYTES;
|
||||
}
|
||||
|
||||
//Squeezes remaining bytes
|
||||
memcpy(ptr, state, (len % BLOCK_LEN_BYTES));
|
||||
//Squeezes remaining bytes
|
||||
memcpy(ptr, state, (len % BLOCK_LEN_BYTES));
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -109,23 +109,24 @@ inline void squeeze(uint64_t *state, byte *out, unsigned int len) {
|
|||
* @param state The current state of the sponge
|
||||
* @param in The block to be absorbed (BLOCK_LEN_INT64 words)
|
||||
*/
|
||||
inline void absorbBlock(uint64_t *state, const uint64_t *in) {
|
||||
//XORs the first BLOCK_LEN_INT64 words of "in" with the current state
|
||||
state[0] ^= in[0];
|
||||
state[1] ^= in[1];
|
||||
state[2] ^= in[2];
|
||||
state[3] ^= in[3];
|
||||
state[4] ^= in[4];
|
||||
state[5] ^= in[5];
|
||||
state[6] ^= in[6];
|
||||
state[7] ^= in[7];
|
||||
state[8] ^= in[8];
|
||||
state[9] ^= in[9];
|
||||
state[10] ^= in[10];
|
||||
state[11] ^= in[11];
|
||||
void absorbBlock(uint64_t *state, const uint64_t *in)
|
||||
{
|
||||
//XORs the first BLOCK_LEN_INT64 words of "in" with the current state
|
||||
state[0] ^= in[0];
|
||||
state[1] ^= in[1];
|
||||
state[2] ^= in[2];
|
||||
state[3] ^= in[3];
|
||||
state[4] ^= in[4];
|
||||
state[5] ^= in[5];
|
||||
state[6] ^= in[6];
|
||||
state[7] ^= in[7];
|
||||
state[8] ^= in[8];
|
||||
state[9] ^= in[9];
|
||||
state[10] ^= in[10];
|
||||
state[11] ^= in[11];
|
||||
|
||||
//Applies the transformation f to the sponge's state
|
||||
blake2bLyra(state);
|
||||
//Applies the transformation f to the sponge's state
|
||||
blake2bLyra(state);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -135,22 +136,21 @@ inline void absorbBlock(uint64_t *state, const uint64_t *in) {
|
|||
* @param state The current state of the sponge
|
||||
* @param in The block to be absorbed (BLOCK_LEN_BLAKE2_SAFE_INT64 words)
|
||||
*/
|
||||
inline void absorbBlockBlake2Safe(uint64_t *state, const uint64_t *in) {
|
||||
//XORs the first BLOCK_LEN_BLAKE2_SAFE_INT64 words of "in" with the current state
|
||||
void absorbBlockBlake2Safe(uint64_t *state, const uint64_t *in)
|
||||
{
|
||||
//XORs the first BLOCK_LEN_BLAKE2_SAFE_INT64 words of "in" with the current state
|
||||
|
||||
state[0] ^= in[0];
|
||||
state[1] ^= in[1];
|
||||
state[2] ^= in[2];
|
||||
state[3] ^= in[3];
|
||||
state[4] ^= in[4];
|
||||
state[5] ^= in[5];
|
||||
state[6] ^= in[6];
|
||||
state[7] ^= in[7];
|
||||
|
||||
|
||||
//Applies the transformation f to the sponge's state
|
||||
blake2bLyra(state);
|
||||
state[1] ^= in[1];
|
||||
state[2] ^= in[2];
|
||||
state[3] ^= in[3];
|
||||
state[4] ^= in[4];
|
||||
state[5] ^= in[5];
|
||||
state[6] ^= in[6];
|
||||
state[7] ^= in[7];
|
||||
|
||||
//Applies the transformation f to the sponge's state
|
||||
blake2bLyra(state);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -161,30 +161,31 @@ inline void absorbBlockBlake2Safe(uint64_t *state, const uint64_t *in) {
|
|||
* @param state The current state of the sponge
|
||||
* @param rowOut Row to receive the data squeezed
|
||||
*/
|
||||
inline void reducedSqueezeRow0(uint64_t* state, uint64_t* rowOut) {
|
||||
uint64_t* ptrWord = rowOut + (N_COLS-1)*BLOCK_LEN_INT64; //In Lyra2: pointer to M[0][C-1]
|
||||
int i;
|
||||
//M[row][C-1-col] = H.reduced_squeeze()
|
||||
for (i = 0; i < N_COLS; i++) {
|
||||
ptrWord[0] = state[0];
|
||||
ptrWord[1] = state[1];
|
||||
ptrWord[2] = state[2];
|
||||
ptrWord[3] = state[3];
|
||||
ptrWord[4] = state[4];
|
||||
ptrWord[5] = state[5];
|
||||
ptrWord[6] = state[6];
|
||||
ptrWord[7] = state[7];
|
||||
ptrWord[8] = state[8];
|
||||
ptrWord[9] = state[9];
|
||||
ptrWord[10] = state[10];
|
||||
ptrWord[11] = state[11];
|
||||
void reducedSqueezeRow0(uint64_t* state, uint64_t* rowOut, const uint32_t nCols)
|
||||
{
|
||||
uint64_t* ptrWord = rowOut + (nCols-1)*BLOCK_LEN_INT64; //In Lyra2: pointer to M[0][C-1]
|
||||
unsigned int i;
|
||||
//M[row][C-1-col] = H.reduced_squeeze()
|
||||
for (i = 0; i < nCols; i++) {
|
||||
ptrWord[0] = state[0];
|
||||
ptrWord[1] = state[1];
|
||||
ptrWord[2] = state[2];
|
||||
ptrWord[3] = state[3];
|
||||
ptrWord[4] = state[4];
|
||||
ptrWord[5] = state[5];
|
||||
ptrWord[6] = state[6];
|
||||
ptrWord[7] = state[7];
|
||||
ptrWord[8] = state[8];
|
||||
ptrWord[9] = state[9];
|
||||
ptrWord[10] = state[10];
|
||||
ptrWord[11] = state[11];
|
||||
|
||||
//Goes to next block (column) that will receive the squeezed data
|
||||
ptrWord -= BLOCK_LEN_INT64;
|
||||
//Goes to next block (column) that will receive the squeezed data
|
||||
ptrWord -= BLOCK_LEN_INT64;
|
||||
|
||||
//Applies the reduced-round transformation f to the sponge's state
|
||||
reducedBlake2bLyra(state);
|
||||
}
|
||||
//Applies the reduced-round transformation f to the sponge's state
|
||||
reducedBlake2bLyra(state);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -196,50 +197,50 @@ inline void reducedSqueezeRow0(uint64_t* state, uint64_t* rowOut) {
|
|||
* @param rowIn Row to feed the sponge
|
||||
* @param rowOut Row to receive the sponge's output
|
||||
*/
|
||||
inline void reducedDuplexRow1(uint64_t *state, uint64_t *rowIn, uint64_t *rowOut) {
|
||||
uint64_t* ptrWordIn = rowIn; //In Lyra2: pointer to prev
|
||||
uint64_t* ptrWordOut = rowOut + (N_COLS-1)*BLOCK_LEN_INT64; //In Lyra2: pointer to row
|
||||
int i;
|
||||
void reducedDuplexRow1(uint64_t *state, uint64_t *rowIn, uint64_t *rowOut, const uint32_t nCols)
|
||||
{
|
||||
uint64_t* ptrWordIn = rowIn; //In Lyra2: pointer to prev
|
||||
uint64_t* ptrWordOut = rowOut + (nCols-1)*BLOCK_LEN_INT64; //In Lyra2: pointer to row
|
||||
unsigned int i;
|
||||
|
||||
for (i = 0; i < N_COLS; i++) {
|
||||
for (i = 0; i < nCols; i++) {
|
||||
|
||||
//Absorbing "M[prev][col]"
|
||||
state[0] ^= (ptrWordIn[0]);
|
||||
state[1] ^= (ptrWordIn[1]);
|
||||
state[2] ^= (ptrWordIn[2]);
|
||||
state[3] ^= (ptrWordIn[3]);
|
||||
state[4] ^= (ptrWordIn[4]);
|
||||
state[5] ^= (ptrWordIn[5]);
|
||||
state[6] ^= (ptrWordIn[6]);
|
||||
state[7] ^= (ptrWordIn[7]);
|
||||
state[8] ^= (ptrWordIn[8]);
|
||||
state[9] ^= (ptrWordIn[9]);
|
||||
state[10] ^= (ptrWordIn[10]);
|
||||
state[11] ^= (ptrWordIn[11]);
|
||||
//Absorbing "M[prev][col]"
|
||||
state[0] ^= (ptrWordIn[0]);
|
||||
state[1] ^= (ptrWordIn[1]);
|
||||
state[2] ^= (ptrWordIn[2]);
|
||||
state[3] ^= (ptrWordIn[3]);
|
||||
state[4] ^= (ptrWordIn[4]);
|
||||
state[5] ^= (ptrWordIn[5]);
|
||||
state[6] ^= (ptrWordIn[6]);
|
||||
state[7] ^= (ptrWordIn[7]);
|
||||
state[8] ^= (ptrWordIn[8]);
|
||||
state[9] ^= (ptrWordIn[9]);
|
||||
state[10] ^= (ptrWordIn[10]);
|
||||
state[11] ^= (ptrWordIn[11]);
|
||||
|
||||
//Applies the reduced-round transformation f to the sponge's state
|
||||
reducedBlake2bLyra(state);
|
||||
//Applies the reduced-round transformation f to the sponge's state
|
||||
reducedBlake2bLyra(state);
|
||||
|
||||
//M[row][C-1-col] = M[prev][col] XOR rand
|
||||
ptrWordOut[0] = ptrWordIn[0] ^ state[0];
|
||||
ptrWordOut[1] = ptrWordIn[1] ^ state[1];
|
||||
ptrWordOut[2] = ptrWordIn[2] ^ state[2];
|
||||
ptrWordOut[3] = ptrWordIn[3] ^ state[3];
|
||||
ptrWordOut[4] = ptrWordIn[4] ^ state[4];
|
||||
ptrWordOut[5] = ptrWordIn[5] ^ state[5];
|
||||
ptrWordOut[6] = ptrWordIn[6] ^ state[6];
|
||||
ptrWordOut[7] = ptrWordIn[7] ^ state[7];
|
||||
ptrWordOut[8] = ptrWordIn[8] ^ state[8];
|
||||
ptrWordOut[9] = ptrWordIn[9] ^ state[9];
|
||||
ptrWordOut[10] = ptrWordIn[10] ^ state[10];
|
||||
ptrWordOut[11] = ptrWordIn[11] ^ state[11];
|
||||
//M[row][C-1-col] = M[prev][col] XOR rand
|
||||
ptrWordOut[0] = ptrWordIn[0] ^ state[0];
|
||||
ptrWordOut[1] = ptrWordIn[1] ^ state[1];
|
||||
ptrWordOut[2] = ptrWordIn[2] ^ state[2];
|
||||
ptrWordOut[3] = ptrWordIn[3] ^ state[3];
|
||||
ptrWordOut[4] = ptrWordIn[4] ^ state[4];
|
||||
ptrWordOut[5] = ptrWordIn[5] ^ state[5];
|
||||
ptrWordOut[6] = ptrWordIn[6] ^ state[6];
|
||||
ptrWordOut[7] = ptrWordIn[7] ^ state[7];
|
||||
ptrWordOut[8] = ptrWordIn[8] ^ state[8];
|
||||
ptrWordOut[9] = ptrWordIn[9] ^ state[9];
|
||||
ptrWordOut[10] = ptrWordIn[10] ^ state[10];
|
||||
ptrWordOut[11] = ptrWordIn[11] ^ state[11];
|
||||
|
||||
|
||||
//Input: next column (i.e., next block in sequence)
|
||||
ptrWordIn += BLOCK_LEN_INT64;
|
||||
//Output: goes to previous column
|
||||
ptrWordOut -= BLOCK_LEN_INT64;
|
||||
}
|
||||
//Input: next column (i.e., next block in sequence)
|
||||
ptrWordIn += BLOCK_LEN_INT64;
|
||||
//Output: goes to previous column
|
||||
ptrWordOut -= BLOCK_LEN_INT64;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -256,64 +257,66 @@ inline void reducedDuplexRow1(uint64_t *state, uint64_t *rowIn, uint64_t *rowOut
|
|||
* @param rowOut Row receiving the output
|
||||
*
|
||||
*/
|
||||
inline void reducedDuplexRowSetup(uint64_t *state, uint64_t *rowIn, uint64_t *rowInOut, uint64_t *rowOut) {
|
||||
uint64_t* ptrWordIn = rowIn; //In Lyra2: pointer to prev
|
||||
uint64_t* ptrWordInOut = rowInOut; //In Lyra2: pointer to row*
|
||||
uint64_t* ptrWordOut = rowOut + (N_COLS-1)*BLOCK_LEN_INT64; //In Lyra2: pointer to row
|
||||
int i;
|
||||
void reducedDuplexRowSetup(uint64_t *state, uint64_t *rowIn, uint64_t *rowInOut, uint64_t *rowOut, const uint32_t nCols)
|
||||
{
|
||||
uint64_t* ptrWordIn = rowIn; //In Lyra2: pointer to prev
|
||||
uint64_t* ptrWordInOut = rowInOut; //In Lyra2: pointer to row*
|
||||
uint64_t* ptrWordOut = rowOut + (nCols-1)*BLOCK_LEN_INT64; //In Lyra2: pointer to row
|
||||
unsigned int i;
|
||||
|
||||
for (i = 0; i < N_COLS; i++) {
|
||||
//Absorbing "M[prev] [+] M[row*]"
|
||||
state[0] ^= (ptrWordIn[0] + ptrWordInOut[0]);
|
||||
state[1] ^= (ptrWordIn[1] + ptrWordInOut[1]);
|
||||
state[2] ^= (ptrWordIn[2] + ptrWordInOut[2]);
|
||||
state[3] ^= (ptrWordIn[3] + ptrWordInOut[3]);
|
||||
state[4] ^= (ptrWordIn[4] + ptrWordInOut[4]);
|
||||
state[5] ^= (ptrWordIn[5] + ptrWordInOut[5]);
|
||||
state[6] ^= (ptrWordIn[6] + ptrWordInOut[6]);
|
||||
state[7] ^= (ptrWordIn[7] + ptrWordInOut[7]);
|
||||
state[8] ^= (ptrWordIn[8] + ptrWordInOut[8]);
|
||||
state[9] ^= (ptrWordIn[9] + ptrWordInOut[9]);
|
||||
state[10] ^= (ptrWordIn[10] + ptrWordInOut[10]);
|
||||
state[11] ^= (ptrWordIn[11] + ptrWordInOut[11]);
|
||||
for (i = 0; i < nCols; i++) {
|
||||
|
||||
//Applies the reduced-round transformation f to the sponge's state
|
||||
reducedBlake2bLyra(state);
|
||||
//Absorbing "M[prev] [+] M[row*]"
|
||||
state[0] ^= (ptrWordIn[0] + ptrWordInOut[0]);
|
||||
state[1] ^= (ptrWordIn[1] + ptrWordInOut[1]);
|
||||
state[2] ^= (ptrWordIn[2] + ptrWordInOut[2]);
|
||||
state[3] ^= (ptrWordIn[3] + ptrWordInOut[3]);
|
||||
state[4] ^= (ptrWordIn[4] + ptrWordInOut[4]);
|
||||
state[5] ^= (ptrWordIn[5] + ptrWordInOut[5]);
|
||||
state[6] ^= (ptrWordIn[6] + ptrWordInOut[6]);
|
||||
state[7] ^= (ptrWordIn[7] + ptrWordInOut[7]);
|
||||
state[8] ^= (ptrWordIn[8] + ptrWordInOut[8]);
|
||||
state[9] ^= (ptrWordIn[9] + ptrWordInOut[9]);
|
||||
state[10] ^= (ptrWordIn[10] + ptrWordInOut[10]);
|
||||
state[11] ^= (ptrWordIn[11] + ptrWordInOut[11]);
|
||||
|
||||
//M[row][col] = M[prev][col] XOR rand
|
||||
ptrWordOut[0] = ptrWordIn[0] ^ state[0];
|
||||
ptrWordOut[1] = ptrWordIn[1] ^ state[1];
|
||||
ptrWordOut[2] = ptrWordIn[2] ^ state[2];
|
||||
ptrWordOut[3] = ptrWordIn[3] ^ state[3];
|
||||
ptrWordOut[4] = ptrWordIn[4] ^ state[4];
|
||||
ptrWordOut[5] = ptrWordIn[5] ^ state[5];
|
||||
ptrWordOut[6] = ptrWordIn[6] ^ state[6];
|
||||
ptrWordOut[7] = ptrWordIn[7] ^ state[7];
|
||||
ptrWordOut[8] = ptrWordIn[8] ^ state[8];
|
||||
ptrWordOut[9] = ptrWordIn[9] ^ state[9];
|
||||
ptrWordOut[10] = ptrWordIn[10] ^ state[10];
|
||||
ptrWordOut[11] = ptrWordIn[11] ^ state[11];
|
||||
//Applies the reduced-round transformation f to the sponge's state
|
||||
reducedBlake2bLyra(state);
|
||||
|
||||
//M[row*][col] = M[row*][col] XOR rotW(rand)
|
||||
ptrWordInOut[0] ^= state[11];
|
||||
ptrWordInOut[1] ^= state[0];
|
||||
ptrWordInOut[2] ^= state[1];
|
||||
ptrWordInOut[3] ^= state[2];
|
||||
ptrWordInOut[4] ^= state[3];
|
||||
ptrWordInOut[5] ^= state[4];
|
||||
ptrWordInOut[6] ^= state[5];
|
||||
ptrWordInOut[7] ^= state[6];
|
||||
ptrWordInOut[8] ^= state[7];
|
||||
ptrWordInOut[9] ^= state[8];
|
||||
ptrWordInOut[10] ^= state[9];
|
||||
ptrWordInOut[11] ^= state[10];
|
||||
//M[row][col] = M[prev][col] XOR rand
|
||||
ptrWordOut[0] = ptrWordIn[0] ^ state[0];
|
||||
ptrWordOut[1] = ptrWordIn[1] ^ state[1];
|
||||
ptrWordOut[2] = ptrWordIn[2] ^ state[2];
|
||||
ptrWordOut[3] = ptrWordIn[3] ^ state[3];
|
||||
ptrWordOut[4] = ptrWordIn[4] ^ state[4];
|
||||
ptrWordOut[5] = ptrWordIn[5] ^ state[5];
|
||||
ptrWordOut[6] = ptrWordIn[6] ^ state[6];
|
||||
ptrWordOut[7] = ptrWordIn[7] ^ state[7];
|
||||
ptrWordOut[8] = ptrWordIn[8] ^ state[8];
|
||||
ptrWordOut[9] = ptrWordIn[9] ^ state[9];
|
||||
ptrWordOut[10] = ptrWordIn[10] ^ state[10];
|
||||
ptrWordOut[11] = ptrWordIn[11] ^ state[11];
|
||||
|
||||
//Inputs: next column (i.e., next block in sequence)
|
||||
ptrWordInOut += BLOCK_LEN_INT64;
|
||||
ptrWordIn += BLOCK_LEN_INT64;
|
||||
//Output: goes to previous column
|
||||
ptrWordOut -= BLOCK_LEN_INT64;
|
||||
}
|
||||
//M[row*][col] = M[row*][col] XOR rotW(rand)
|
||||
ptrWordInOut[0] ^= state[11];
|
||||
ptrWordInOut[1] ^= state[0];
|
||||
ptrWordInOut[2] ^= state[1];
|
||||
ptrWordInOut[3] ^= state[2];
|
||||
ptrWordInOut[4] ^= state[3];
|
||||
ptrWordInOut[5] ^= state[4];
|
||||
ptrWordInOut[6] ^= state[5];
|
||||
ptrWordInOut[7] ^= state[6];
|
||||
ptrWordInOut[8] ^= state[7];
|
||||
ptrWordInOut[9] ^= state[8];
|
||||
ptrWordInOut[10] ^= state[9];
|
||||
ptrWordInOut[11] ^= state[10];
|
||||
|
||||
//Inputs: next column (i.e., next block in sequence)
|
||||
ptrWordInOut += BLOCK_LEN_INT64;
|
||||
ptrWordIn += BLOCK_LEN_INT64;
|
||||
//Output: goes to previous column
|
||||
ptrWordOut -= BLOCK_LEN_INT64;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -330,416 +333,78 @@ inline void reducedDuplexRowSetup(uint64_t *state, uint64_t *rowIn, uint64_t *ro
|
|||
* @param rowOut Row receiving the output
|
||||
*
|
||||
*/
|
||||
inline void reducedDuplexRow(uint64_t *state, uint64_t *rowIn, uint64_t *rowInOut, uint64_t *rowOut) {
|
||||
uint64_t* ptrWordInOut = rowInOut; //In Lyra2: pointer to row*
|
||||
uint64_t* ptrWordIn = rowIn; //In Lyra2: pointer to prev
|
||||
uint64_t* ptrWordOut = rowOut; //In Lyra2: pointer to row
|
||||
int i;
|
||||
void reducedDuplexRow(uint64_t *state, uint64_t *rowIn, uint64_t *rowInOut, uint64_t *rowOut, const uint32_t nCols)
|
||||
{
|
||||
uint64_t* ptrWordInOut = rowInOut; //In Lyra2: pointer to row*
|
||||
uint64_t* ptrWordIn = rowIn; //In Lyra2: pointer to prev
|
||||
uint64_t* ptrWordOut = rowOut; //In Lyra2: pointer to row
|
||||
unsigned int i;
|
||||
|
||||
for (i = 0; i < N_COLS; i++) {
|
||||
for (i = 0; i < nCols; i++) {
|
||||
|
||||
//Absorbing "M[prev] [+] M[row*]"
|
||||
state[0] ^= (ptrWordIn[0] + ptrWordInOut[0]);
|
||||
state[1] ^= (ptrWordIn[1] + ptrWordInOut[1]);
|
||||
state[2] ^= (ptrWordIn[2] + ptrWordInOut[2]);
|
||||
state[3] ^= (ptrWordIn[3] + ptrWordInOut[3]);
|
||||
state[4] ^= (ptrWordIn[4] + ptrWordInOut[4]);
|
||||
state[5] ^= (ptrWordIn[5] + ptrWordInOut[5]);
|
||||
state[6] ^= (ptrWordIn[6] + ptrWordInOut[6]);
|
||||
state[7] ^= (ptrWordIn[7] + ptrWordInOut[7]);
|
||||
state[8] ^= (ptrWordIn[8] + ptrWordInOut[8]);
|
||||
state[9] ^= (ptrWordIn[9] + ptrWordInOut[9]);
|
||||
state[10] ^= (ptrWordIn[10] + ptrWordInOut[10]);
|
||||
state[11] ^= (ptrWordIn[11] + ptrWordInOut[11]);
|
||||
//Absorbing "M[prev] [+] M[row*]"
|
||||
state[0] ^= (ptrWordIn[0] + ptrWordInOut[0]);
|
||||
state[1] ^= (ptrWordIn[1] + ptrWordInOut[1]);
|
||||
state[2] ^= (ptrWordIn[2] + ptrWordInOut[2]);
|
||||
state[3] ^= (ptrWordIn[3] + ptrWordInOut[3]);
|
||||
state[4] ^= (ptrWordIn[4] + ptrWordInOut[4]);
|
||||
state[5] ^= (ptrWordIn[5] + ptrWordInOut[5]);
|
||||
state[6] ^= (ptrWordIn[6] + ptrWordInOut[6]);
|
||||
state[7] ^= (ptrWordIn[7] + ptrWordInOut[7]);
|
||||
state[8] ^= (ptrWordIn[8] + ptrWordInOut[8]);
|
||||
state[9] ^= (ptrWordIn[9] + ptrWordInOut[9]);
|
||||
state[10] ^= (ptrWordIn[10] + ptrWordInOut[10]);
|
||||
state[11] ^= (ptrWordIn[11] + ptrWordInOut[11]);
|
||||
|
||||
//Applies the reduced-round transformation f to the sponge's state
|
||||
reducedBlake2bLyra(state);
|
||||
//Applies the reduced-round transformation f to the sponge's state
|
||||
reducedBlake2bLyra(state);
|
||||
|
||||
//M[rowOut][col] = M[rowOut][col] XOR rand
|
||||
ptrWordOut[0] ^= state[0];
|
||||
ptrWordOut[1] ^= state[1];
|
||||
ptrWordOut[2] ^= state[2];
|
||||
ptrWordOut[3] ^= state[3];
|
||||
ptrWordOut[4] ^= state[4];
|
||||
ptrWordOut[5] ^= state[5];
|
||||
ptrWordOut[6] ^= state[6];
|
||||
ptrWordOut[7] ^= state[7];
|
||||
ptrWordOut[8] ^= state[8];
|
||||
ptrWordOut[9] ^= state[9];
|
||||
ptrWordOut[10] ^= state[10];
|
||||
ptrWordOut[11] ^= state[11];
|
||||
//M[rowOut][col] = M[rowOut][col] XOR rand
|
||||
ptrWordOut[0] ^= state[0];
|
||||
ptrWordOut[1] ^= state[1];
|
||||
ptrWordOut[2] ^= state[2];
|
||||
ptrWordOut[3] ^= state[3];
|
||||
ptrWordOut[4] ^= state[4];
|
||||
ptrWordOut[5] ^= state[5];
|
||||
ptrWordOut[6] ^= state[6];
|
||||
ptrWordOut[7] ^= state[7];
|
||||
ptrWordOut[8] ^= state[8];
|
||||
ptrWordOut[9] ^= state[9];
|
||||
ptrWordOut[10] ^= state[10];
|
||||
ptrWordOut[11] ^= state[11];
|
||||
|
||||
//M[rowInOut][col] = M[rowInOut][col] XOR rotW(rand)
|
||||
ptrWordInOut[0] ^= state[11];
|
||||
ptrWordInOut[1] ^= state[0];
|
||||
ptrWordInOut[2] ^= state[1];
|
||||
ptrWordInOut[3] ^= state[2];
|
||||
ptrWordInOut[4] ^= state[3];
|
||||
ptrWordInOut[5] ^= state[4];
|
||||
ptrWordInOut[6] ^= state[5];
|
||||
ptrWordInOut[7] ^= state[6];
|
||||
ptrWordInOut[8] ^= state[7];
|
||||
ptrWordInOut[9] ^= state[8];
|
||||
ptrWordInOut[10] ^= state[9];
|
||||
ptrWordInOut[11] ^= state[10];
|
||||
//M[rowInOut][col] = M[rowInOut][col] XOR rotW(rand)
|
||||
ptrWordInOut[0] ^= state[11];
|
||||
ptrWordInOut[1] ^= state[0];
|
||||
ptrWordInOut[2] ^= state[1];
|
||||
ptrWordInOut[3] ^= state[2];
|
||||
ptrWordInOut[4] ^= state[3];
|
||||
ptrWordInOut[5] ^= state[4];
|
||||
ptrWordInOut[6] ^= state[5];
|
||||
ptrWordInOut[7] ^= state[6];
|
||||
ptrWordInOut[8] ^= state[7];
|
||||
ptrWordInOut[9] ^= state[8];
|
||||
ptrWordInOut[10] ^= state[9];
|
||||
ptrWordInOut[11] ^= state[10];
|
||||
|
||||
//Goes to next block
|
||||
ptrWordOut += BLOCK_LEN_INT64;
|
||||
ptrWordInOut += BLOCK_LEN_INT64;
|
||||
ptrWordIn += BLOCK_LEN_INT64;
|
||||
}
|
||||
//Goes to next block
|
||||
ptrWordOut += BLOCK_LEN_INT64;
|
||||
ptrWordInOut += BLOCK_LEN_INT64;
|
||||
ptrWordIn += BLOCK_LEN_INT64;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/**
|
||||
* Performs a duplex operation over "M[rowInOut] [+] M[rowIn]", writing the output "rand"
|
||||
* on M[rowOut] and making "M[rowInOut] = M[rowInOut] XOR rotW(rand)", where rotW is a 64-bit
|
||||
* rotation to the left.
|
||||
*
|
||||
* @param state The current state of the sponge
|
||||
* @param rowIn Row used only as input
|
||||
* @param rowInOut Row used as input and to receive output after rotation
|
||||
* @param rowOut Row receiving the output
|
||||
*
|
||||
* Prints an array of unsigned chars
|
||||
*/
|
||||
/*
|
||||
inline void reducedDuplexRowSetupOLD(uint64_t *state, uint64_t *rowIn, uint64_t *rowInOut, uint64_t *rowOut) {
|
||||
uint64_t* ptrWordIn = rowIn; //In Lyra2: pointer to prev
|
||||
uint64_t* ptrWordInOut = rowInOut; //In Lyra2: pointer to row*
|
||||
uint64_t* ptrWordOut = rowOut; //In Lyra2: pointer to row
|
||||
int i;
|
||||
for (i = 0; i < N_COLS; i++) {
|
||||
|
||||
//Absorbing "M[rowInOut] XOR M[rowIn]"
|
||||
state[0] ^= ptrWordInOut[0] ^ ptrWordIn[0];
|
||||
state[1] ^= ptrWordInOut[1] ^ ptrWordIn[1];
|
||||
state[2] ^= ptrWordInOut[2] ^ ptrWordIn[2];
|
||||
state[3] ^= ptrWordInOut[3] ^ ptrWordIn[3];
|
||||
state[4] ^= ptrWordInOut[4] ^ ptrWordIn[4];
|
||||
state[5] ^= ptrWordInOut[5] ^ ptrWordIn[5];
|
||||
state[6] ^= ptrWordInOut[6] ^ ptrWordIn[6];
|
||||
state[7] ^= ptrWordInOut[7] ^ ptrWordIn[7];
|
||||
state[8] ^= ptrWordInOut[8] ^ ptrWordIn[8];
|
||||
state[9] ^= ptrWordInOut[9] ^ ptrWordIn[9];
|
||||
state[10] ^= ptrWordInOut[10] ^ ptrWordIn[10];
|
||||
state[11] ^= ptrWordInOut[11] ^ ptrWordIn[11];
|
||||
|
||||
//Applies the reduced-round transformation f to the sponge's state
|
||||
reducedBlake2bLyra(state);
|
||||
|
||||
//M[row][col] = rand
|
||||
ptrWordOut[0] = state[0];
|
||||
ptrWordOut[1] = state[1];
|
||||
ptrWordOut[2] = state[2];
|
||||
ptrWordOut[3] = state[3];
|
||||
ptrWordOut[4] = state[4];
|
||||
ptrWordOut[5] = state[5];
|
||||
ptrWordOut[6] = state[6];
|
||||
ptrWordOut[7] = state[7];
|
||||
ptrWordOut[8] = state[8];
|
||||
ptrWordOut[9] = state[9];
|
||||
ptrWordOut[10] = state[10];
|
||||
ptrWordOut[11] = state[11];
|
||||
|
||||
|
||||
//M[row*][col] = M[row*][col] XOR rotW(rand)
|
||||
ptrWordInOut[0] ^= state[10];
|
||||
ptrWordInOut[1] ^= state[11];
|
||||
ptrWordInOut[2] ^= state[0];
|
||||
ptrWordInOut[3] ^= state[1];
|
||||
ptrWordInOut[4] ^= state[2];
|
||||
ptrWordInOut[5] ^= state[3];
|
||||
ptrWordInOut[6] ^= state[4];
|
||||
ptrWordInOut[7] ^= state[5];
|
||||
ptrWordInOut[8] ^= state[6];
|
||||
ptrWordInOut[9] ^= state[7];
|
||||
ptrWordInOut[10] ^= state[8];
|
||||
ptrWordInOut[11] ^= state[9];
|
||||
|
||||
//Goes to next column (i.e., next block in sequence)
|
||||
ptrWordInOut += BLOCK_LEN_INT64;
|
||||
ptrWordIn += BLOCK_LEN_INT64;
|
||||
ptrWordOut += BLOCK_LEN_INT64;
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
/**
|
||||
* Performs a duplex operation over "M[rowInOut] XOR M[rowIn]", writing the output "rand"
|
||||
* on M[rowOut] and making "M[rowInOut] = M[rowInOut] XOR rotW(rand)", where rotW is a 64-bit
|
||||
* rotation to the left.
|
||||
*
|
||||
* @param state The current state of the sponge
|
||||
* @param rowIn Row used only as input
|
||||
* @param rowInOut Row used as input and to receive output after rotation
|
||||
* @param rowOut Row receiving the output
|
||||
*
|
||||
*/
|
||||
/*
|
||||
inline void reducedDuplexRowSetupv5(uint64_t *state, uint64_t *rowIn, uint64_t *rowInOut, uint64_t *rowOut) {
|
||||
uint64_t* ptrWordIn = rowIn; //In Lyra2: pointer to prev
|
||||
uint64_t* ptrWordInOut = rowInOut; //In Lyra2: pointer to row*
|
||||
uint64_t* ptrWordOut = rowOut; //In Lyra2: pointer to row
|
||||
int i;
|
||||
for (i = 0; i < N_COLS; i++) {
|
||||
|
||||
//Absorbing "M[rowInOut] XOR M[rowIn]"
|
||||
state[0] ^= ptrWordInOut[0] + ptrWordIn[0];
|
||||
state[1] ^= ptrWordInOut[1] + ptrWordIn[1];
|
||||
state[2] ^= ptrWordInOut[2] + ptrWordIn[2];
|
||||
state[3] ^= ptrWordInOut[3] + ptrWordIn[3];
|
||||
state[4] ^= ptrWordInOut[4] + ptrWordIn[4];
|
||||
state[5] ^= ptrWordInOut[5] + ptrWordIn[5];
|
||||
state[6] ^= ptrWordInOut[6] + ptrWordIn[6];
|
||||
state[7] ^= ptrWordInOut[7] + ptrWordIn[7];
|
||||
state[8] ^= ptrWordInOut[8] + ptrWordIn[8];
|
||||
state[9] ^= ptrWordInOut[9] + ptrWordIn[9];
|
||||
state[10] ^= ptrWordInOut[10] + ptrWordIn[10];
|
||||
state[11] ^= ptrWordInOut[11] + ptrWordIn[11];
|
||||
|
||||
//Applies the reduced-round transformation f to the sponge's state
|
||||
reducedBlake2bLyra(state);
|
||||
|
||||
|
||||
//M[row*][col] = M[row*][col] XOR rotW(rand)
|
||||
ptrWordInOut[0] ^= state[10];
|
||||
ptrWordInOut[1] ^= state[11];
|
||||
ptrWordInOut[2] ^= state[0];
|
||||
ptrWordInOut[3] ^= state[1];
|
||||
ptrWordInOut[4] ^= state[2];
|
||||
ptrWordInOut[5] ^= state[3];
|
||||
ptrWordInOut[6] ^= state[4];
|
||||
ptrWordInOut[7] ^= state[5];
|
||||
ptrWordInOut[8] ^= state[6];
|
||||
ptrWordInOut[9] ^= state[7];
|
||||
ptrWordInOut[10] ^= state[8];
|
||||
ptrWordInOut[11] ^= state[9];
|
||||
|
||||
|
||||
//M[row][col] = rand
|
||||
ptrWordOut[0] = state[0] ^ ptrWordIn[0];
|
||||
ptrWordOut[1] = state[1] ^ ptrWordIn[1];
|
||||
ptrWordOut[2] = state[2] ^ ptrWordIn[2];
|
||||
ptrWordOut[3] = state[3] ^ ptrWordIn[3];
|
||||
ptrWordOut[4] = state[4] ^ ptrWordIn[4];
|
||||
ptrWordOut[5] = state[5] ^ ptrWordIn[5];
|
||||
ptrWordOut[6] = state[6] ^ ptrWordIn[6];
|
||||
ptrWordOut[7] = state[7] ^ ptrWordIn[7];
|
||||
ptrWordOut[8] = state[8] ^ ptrWordIn[8];
|
||||
ptrWordOut[9] = state[9] ^ ptrWordIn[9];
|
||||
ptrWordOut[10] = state[10] ^ ptrWordIn[10];
|
||||
ptrWordOut[11] = state[11] ^ ptrWordIn[11];
|
||||
|
||||
//Goes to next column (i.e., next block in sequence)
|
||||
ptrWordInOut += BLOCK_LEN_INT64;
|
||||
ptrWordIn += BLOCK_LEN_INT64;
|
||||
ptrWordOut += BLOCK_LEN_INT64;
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
/**
|
||||
* Performs a duplex operation over "M[rowInOut] XOR M[rowIn]", writing the output "rand"
|
||||
* on M[rowOut] and making "M[rowInOut] = M[rowInOut] XOR rotW(rand)", where rotW is a 64-bit
|
||||
* rotation to the left.
|
||||
*
|
||||
* @param state The current state of the sponge
|
||||
* @param rowIn Row used only as input
|
||||
* @param rowInOut Row used as input and to receive output after rotation
|
||||
* @param rowOut Row receiving the output
|
||||
*
|
||||
*/
|
||||
/*
|
||||
inline void reducedDuplexRowSetupv5c(uint64_t *state, uint64_t *rowIn, uint64_t *rowInOut, uint64_t *rowOut) {
|
||||
uint64_t* ptrWordIn = rowIn; //In Lyra2: pointer to prev
|
||||
uint64_t* ptrWordInOut = rowInOut; //In Lyra2: pointer to row*
|
||||
uint64_t* ptrWordOut = rowOut;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < N_COLS / 2; i++) {
|
||||
//Absorbing "M[rowInOut] XOR M[rowIn]"
|
||||
state[0] ^= ptrWordInOut[0] + ptrWordIn[0];
|
||||
state[1] ^= ptrWordInOut[1] + ptrWordIn[1];
|
||||
state[2] ^= ptrWordInOut[2] + ptrWordIn[2];
|
||||
state[3] ^= ptrWordInOut[3] + ptrWordIn[3];
|
||||
state[4] ^= ptrWordInOut[4] + ptrWordIn[4];
|
||||
state[5] ^= ptrWordInOut[5] + ptrWordIn[5];
|
||||
state[6] ^= ptrWordInOut[6] + ptrWordIn[6];
|
||||
state[7] ^= ptrWordInOut[7] + ptrWordIn[7];
|
||||
state[8] ^= ptrWordInOut[8] + ptrWordIn[8];
|
||||
state[9] ^= ptrWordInOut[9] + ptrWordIn[9];
|
||||
state[10] ^= ptrWordInOut[10] + ptrWordIn[10];
|
||||
state[11] ^= ptrWordInOut[11] + ptrWordIn[11];
|
||||
|
||||
//Applies the reduced-round transformation f to the sponge's state
|
||||
reducedBlake2bLyra(state);
|
||||
|
||||
|
||||
//M[row*][col] = M[row*][col] XOR rotW(rand)
|
||||
ptrWordInOut[0] ^= state[10];
|
||||
ptrWordInOut[1] ^= state[11];
|
||||
ptrWordInOut[2] ^= state[0];
|
||||
ptrWordInOut[3] ^= state[1];
|
||||
ptrWordInOut[4] ^= state[2];
|
||||
ptrWordInOut[5] ^= state[3];
|
||||
ptrWordInOut[6] ^= state[4];
|
||||
ptrWordInOut[7] ^= state[5];
|
||||
ptrWordInOut[8] ^= state[6];
|
||||
ptrWordInOut[9] ^= state[7];
|
||||
ptrWordInOut[10] ^= state[8];
|
||||
ptrWordInOut[11] ^= state[9];
|
||||
|
||||
|
||||
//M[row][col] = rand
|
||||
ptrWordOut[0] = state[0] ^ ptrWordIn[0];
|
||||
ptrWordOut[1] = state[1] ^ ptrWordIn[1];
|
||||
ptrWordOut[2] = state[2] ^ ptrWordIn[2];
|
||||
ptrWordOut[3] = state[3] ^ ptrWordIn[3];
|
||||
ptrWordOut[4] = state[4] ^ ptrWordIn[4];
|
||||
ptrWordOut[5] = state[5] ^ ptrWordIn[5];
|
||||
ptrWordOut[6] = state[6] ^ ptrWordIn[6];
|
||||
ptrWordOut[7] = state[7] ^ ptrWordIn[7];
|
||||
ptrWordOut[8] = state[8] ^ ptrWordIn[8];
|
||||
ptrWordOut[9] = state[9] ^ ptrWordIn[9];
|
||||
ptrWordOut[10] = state[10] ^ ptrWordIn[10];
|
||||
ptrWordOut[11] = state[11] ^ ptrWordIn[11];
|
||||
|
||||
//Goes to next column (i.e., next block in sequence)
|
||||
ptrWordInOut += BLOCK_LEN_INT64;
|
||||
ptrWordIn += BLOCK_LEN_INT64;
|
||||
ptrWordOut += 2 * BLOCK_LEN_INT64;
|
||||
}
|
||||
|
||||
ptrWordOut = rowOut + BLOCK_LEN_INT64;
|
||||
for (i = 0; i < N_COLS / 2; i++) {
|
||||
//Absorbing "M[rowInOut] XOR M[rowIn]"
|
||||
state[0] ^= ptrWordInOut[0] + ptrWordIn[0];
|
||||
state[1] ^= ptrWordInOut[1] + ptrWordIn[1];
|
||||
state[2] ^= ptrWordInOut[2] + ptrWordIn[2];
|
||||
state[3] ^= ptrWordInOut[3] + ptrWordIn[3];
|
||||
state[4] ^= ptrWordInOut[4] + ptrWordIn[4];
|
||||
state[5] ^= ptrWordInOut[5] + ptrWordIn[5];
|
||||
state[6] ^= ptrWordInOut[6] + ptrWordIn[6];
|
||||
state[7] ^= ptrWordInOut[7] + ptrWordIn[7];
|
||||
state[8] ^= ptrWordInOut[8] + ptrWordIn[8];
|
||||
state[9] ^= ptrWordInOut[9] + ptrWordIn[9];
|
||||
state[10] ^= ptrWordInOut[10] + ptrWordIn[10];
|
||||
state[11] ^= ptrWordInOut[11] + ptrWordIn[11];
|
||||
|
||||
//Applies the reduced-round transformation f to the sponge's state
|
||||
reducedBlake2bLyra(state);
|
||||
|
||||
|
||||
//M[row*][col] = M[row*][col] XOR rotW(rand)
|
||||
ptrWordInOut[0] ^= state[10];
|
||||
ptrWordInOut[1] ^= state[11];
|
||||
ptrWordInOut[2] ^= state[0];
|
||||
ptrWordInOut[3] ^= state[1];
|
||||
ptrWordInOut[4] ^= state[2];
|
||||
ptrWordInOut[5] ^= state[3];
|
||||
ptrWordInOut[6] ^= state[4];
|
||||
ptrWordInOut[7] ^= state[5];
|
||||
ptrWordInOut[8] ^= state[6];
|
||||
ptrWordInOut[9] ^= state[7];
|
||||
ptrWordInOut[10] ^= state[8];
|
||||
ptrWordInOut[11] ^= state[9];
|
||||
|
||||
|
||||
//M[row][col] = rand
|
||||
ptrWordOut[0] = state[0] ^ ptrWordIn[0];
|
||||
ptrWordOut[1] = state[1] ^ ptrWordIn[1];
|
||||
ptrWordOut[2] = state[2] ^ ptrWordIn[2];
|
||||
ptrWordOut[3] = state[3] ^ ptrWordIn[3];
|
||||
ptrWordOut[4] = state[4] ^ ptrWordIn[4];
|
||||
ptrWordOut[5] = state[5] ^ ptrWordIn[5];
|
||||
ptrWordOut[6] = state[6] ^ ptrWordIn[6];
|
||||
ptrWordOut[7] = state[7] ^ ptrWordIn[7];
|
||||
ptrWordOut[8] = state[8] ^ ptrWordIn[8];
|
||||
ptrWordOut[9] = state[9] ^ ptrWordIn[9];
|
||||
ptrWordOut[10] = state[10] ^ ptrWordIn[10];
|
||||
ptrWordOut[11] = state[11] ^ ptrWordIn[11];
|
||||
|
||||
//Goes to next column (i.e., next block in sequence)
|
||||
ptrWordInOut += BLOCK_LEN_INT64;
|
||||
ptrWordIn += BLOCK_LEN_INT64;
|
||||
ptrWordOut += 2 * BLOCK_LEN_INT64;
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
/**
|
||||
* Performs a duplex operation over "M[rowInOut] XOR M[rowIn]", using the output "rand"
|
||||
* to make "M[rowOut][col] = M[rowOut][col] XOR rand" and "M[rowInOut] = M[rowInOut] XOR rotW(rand)",
|
||||
* where rotW is a 64-bit rotation to the left.
|
||||
*
|
||||
* @param state The current state of the sponge
|
||||
* @param rowIn Row used only as input
|
||||
* @param rowInOut Row used as input and to receive output after rotation
|
||||
* @param rowOut Row receiving the output
|
||||
*
|
||||
*/
|
||||
/*
|
||||
inline void reducedDuplexRowd(uint64_t *state, uint64_t *rowIn, uint64_t *rowInOut, uint64_t *rowOut) {
|
||||
uint64_t* ptrWordInOut = rowInOut; //In Lyra2: pointer to row*
|
||||
uint64_t* ptrWordIn = rowIn; //In Lyra2: pointer to prev
|
||||
uint64_t* ptrWordOut = rowOut; //In Lyra2: pointer to row
|
||||
int i;
|
||||
for (i = 0; i < N_COLS; i++) {
|
||||
|
||||
//Absorbing "M[rowInOut] XOR M[rowIn]"
|
||||
state[0] ^= ptrWordInOut[0] + ptrWordIn[0];
|
||||
state[1] ^= ptrWordInOut[1] + ptrWordIn[1];
|
||||
state[2] ^= ptrWordInOut[2] + ptrWordIn[2];
|
||||
state[3] ^= ptrWordInOut[3] + ptrWordIn[3];
|
||||
state[4] ^= ptrWordInOut[4] + ptrWordIn[4];
|
||||
state[5] ^= ptrWordInOut[5] + ptrWordIn[5];
|
||||
state[6] ^= ptrWordInOut[6] + ptrWordIn[6];
|
||||
state[7] ^= ptrWordInOut[7] + ptrWordIn[7];
|
||||
state[8] ^= ptrWordInOut[8] + ptrWordIn[8];
|
||||
state[9] ^= ptrWordInOut[9] + ptrWordIn[9];
|
||||
state[10] ^= ptrWordInOut[10] + ptrWordIn[10];
|
||||
state[11] ^= ptrWordInOut[11] + ptrWordIn[11];
|
||||
|
||||
//Applies the reduced-round transformation f to the sponge's state
|
||||
reducedBlake2bLyra(state);
|
||||
|
||||
//M[rowOut][col] = M[rowOut][col] XOR rand
|
||||
ptrWordOut[0] ^= state[0];
|
||||
ptrWordOut[1] ^= state[1];
|
||||
ptrWordOut[2] ^= state[2];
|
||||
ptrWordOut[3] ^= state[3];
|
||||
ptrWordOut[4] ^= state[4];
|
||||
ptrWordOut[5] ^= state[5];
|
||||
ptrWordOut[6] ^= state[6];
|
||||
ptrWordOut[7] ^= state[7];
|
||||
ptrWordOut[8] ^= state[8];
|
||||
ptrWordOut[9] ^= state[9];
|
||||
ptrWordOut[10] ^= state[10];
|
||||
ptrWordOut[11] ^= state[11];
|
||||
|
||||
//M[rowInOut][col] = M[rowInOut][col] XOR rotW(rand)
|
||||
|
||||
|
||||
//Goes to next block
|
||||
ptrWordOut += BLOCK_LEN_INT64;
|
||||
ptrWordInOut += BLOCK_LEN_INT64;
|
||||
ptrWordIn += BLOCK_LEN_INT64;
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
/**
|
||||
Prints an array of unsigned chars
|
||||
*/
|
||||
void printArray(unsigned char *array, unsigned int size, char *name) {
|
||||
int i;
|
||||
printf("%s: ", name);
|
||||
for (i = 0; i < size; i++) {
|
||||
printf("%2x|", array[i]);
|
||||
}
|
||||
printf("\n");
|
||||
void printArray(unsigned char *array, unsigned int size, char *name)
|
||||
{
|
||||
unsigned int i;
|
||||
printf("%s: ", name);
|
||||
for (i = 0; i < size; i++) {
|
||||
printf("%2x|", array[i]);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
|
|||
|
|
@ -22,94 +22,67 @@
|
|||
#ifndef SPONGE_H_
|
||||
#define SPONGE_H_
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"{
|
||||
#endif
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#if defined(__GNUC__)
|
||||
#define ALIGN __attribute__ ((aligned(32)))
|
||||
#elif defined(_MSC_VER)
|
||||
#define ALIGN __declspec(align(32))
|
||||
#else
|
||||
#define ALIGN
|
||||
#endif
|
||||
|
||||
|
||||
/*Blake2b IV Array*/
|
||||
/* Blake2b IV Array */
|
||||
static const uint64_t blake2b_IV[8] =
|
||||
{
|
||||
0x6a09e667f3bcc908ULL, 0xbb67ae8584caa73bULL,
|
||||
0x3c6ef372fe94f82bULL, 0xa54ff53a5f1d36f1ULL,
|
||||
0x510e527fade682d1ULL, 0x9b05688c2b3e6c1fULL,
|
||||
0x1f83d9abfb41bd6bULL, 0x5be0cd19137e2179ULL
|
||||
0x6a09e667f3bcc908ULL, 0xbb67ae8584caa73bULL,
|
||||
0x3c6ef372fe94f82bULL, 0xa54ff53a5f1d36f1ULL,
|
||||
0x510e527fade682d1ULL, 0x9b05688c2b3e6c1fULL,
|
||||
0x1f83d9abfb41bd6bULL, 0x5be0cd19137e2179ULL
|
||||
};
|
||||
|
||||
/*Blake2b's rotation*/
|
||||
static inline uint64_t rotr64( const uint64_t w, const unsigned c ){
|
||||
return ( w >> c ) | ( w << ( 64 - c ) );
|
||||
/* Blake2b's rotation */
|
||||
static __inline uint64_t rotr64(const uint64_t w, const unsigned c) {
|
||||
#ifdef _MSC_VER
|
||||
return _rotr64(w, c);
|
||||
#else
|
||||
return ( w >> c ) | ( w << ( 64 - c ) );
|
||||
#endif
|
||||
}
|
||||
|
||||
/*Blake2b's G function*/
|
||||
#define G(r,i,a,b,c,d) \
|
||||
do { \
|
||||
a = a + b; \
|
||||
d = rotr64(d ^ a, 32); \
|
||||
c = c + d; \
|
||||
b = rotr64(b ^ c, 24); \
|
||||
a = a + b; \
|
||||
d = rotr64(d ^ a, 16); \
|
||||
c = c + d; \
|
||||
b = rotr64(b ^ c, 63); \
|
||||
/* Blake2b's G function */
|
||||
#define G(r,i,a,b,c,d) do { \
|
||||
a = a + b; \
|
||||
d = rotr64(d ^ a, 32); \
|
||||
c = c + d; \
|
||||
b = rotr64(b ^ c, 24); \
|
||||
a = a + b; \
|
||||
d = rotr64(d ^ a, 16); \
|
||||
c = c + d; \
|
||||
b = rotr64(b ^ c, 63); \
|
||||
} while(0)
|
||||
|
||||
|
||||
/*One Round of the Blake2b's compression function*/
|
||||
#define ROUND_LYRA(r) \
|
||||
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]);
|
||||
|
||||
#define ROUND_LYRA(r) \
|
||||
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]);
|
||||
|
||||
//---- Housekeeping
|
||||
void initState(uint64_t state[/*16*/]);
|
||||
|
||||
//---- Squeezes
|
||||
void squeeze(uint64_t *state, unsigned char *out, unsigned int len);
|
||||
void reducedSqueezeRow0(uint64_t* state, uint64_t* row);
|
||||
void reducedSqueezeRow0(uint64_t* state, uint64_t* row, const uint32_t nCols);
|
||||
|
||||
//---- Absorbs
|
||||
void absorbBlock(uint64_t *state, const uint64_t *in);
|
||||
void absorbBlockBlake2Safe(uint64_t *state, const uint64_t *in);
|
||||
|
||||
//---- Duplexes
|
||||
void reducedDuplexRow1(uint64_t *state, uint64_t *rowIn, uint64_t *rowOut);
|
||||
void reducedDuplexRowSetup(uint64_t *state, uint64_t *rowIn, uint64_t *rowInOut, uint64_t *rowOut);
|
||||
void reducedDuplexRow(uint64_t *state, uint64_t *rowIn, uint64_t *rowInOut, uint64_t *rowOut);
|
||||
void reducedDuplexRow1(uint64_t *state, uint64_t *rowIn, uint64_t *rowOut, const uint32_t nCols);
|
||||
void reducedDuplexRowSetup(uint64_t *state, uint64_t *rowIn, uint64_t *rowInOut, uint64_t *rowOut, const uint32_t nCols);
|
||||
void reducedDuplexRow(uint64_t *state, uint64_t *rowIn, uint64_t *rowInOut, uint64_t *rowOut, const uint32_t nCols);
|
||||
|
||||
//---- Misc
|
||||
void printArray(unsigned char *array, unsigned int size, char *name);
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
////TESTS////
|
||||
//void reducedDuplexRowc(uint64_t *state, uint64_t *rowIn, uint64_t *rowInOut, uint64_t *rowOut);
|
||||
//void reducedDuplexRowd(uint64_t *state, uint64_t *rowIn, uint64_t *rowInOut, uint64_t *rowOut);
|
||||
//void reducedDuplexRowSetupv4(uint64_t *state, uint64_t *rowIn1, uint64_t *rowIn2, uint64_t *rowOut1, uint64_t *rowOut2);
|
||||
//void reducedDuplexRowSetupv5(uint64_t *state, uint64_t *rowIn, uint64_t *rowInOut, uint64_t *rowOut);
|
||||
//void reducedDuplexRowSetupv5c(uint64_t *state, uint64_t *rowIn, uint64_t *rowInOut, uint64_t *rowOut);
|
||||
//void reducedDuplexRowSetupv5d(uint64_t *state, uint64_t *rowIn, uint64_t *rowInOut, uint64_t *rowOut);
|
||||
/////////////
|
||||
|
||||
|
||||
#endif /* SPONGE_H_ */
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -27,7 +27,6 @@
|
|||
* online backup system.
|
||||
*/
|
||||
|
||||
#include "Lyra2RE.h"
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
|
|
@ -38,26 +37,26 @@
|
|||
#include "../sha3/sph_skein.h"
|
||||
#include "Lyra2.h"
|
||||
|
||||
void lyra2re_hash(const char* input, char* output)
|
||||
void lyra2re_hash(const char* input, char* output, uint32_t len)
|
||||
{
|
||||
uint32_t hashA[8], hashB[8];
|
||||
|
||||
sph_blake256_context ctx_blake;
|
||||
sph_groestl256_context ctx_groestl;
|
||||
sph_keccak256_context ctx_keccak;
|
||||
sph_skein256_context ctx_skein;
|
||||
|
||||
uint32_t hashA[8], hashB[8];
|
||||
|
||||
sph_blake256_init(&ctx_blake);
|
||||
sph_blake256 (&ctx_blake, input, 80);
|
||||
sph_blake256 (&ctx_blake, input, len); /* 80 */
|
||||
sph_blake256_close (&ctx_blake, hashA);
|
||||
|
||||
sph_keccak256_init(&ctx_keccak);
|
||||
sph_keccak256 (&ctx_keccak,hashA, 32);
|
||||
sph_keccak256_close(&ctx_keccak, hashB);
|
||||
|
||||
LYRA2((void*)hashA, 32, (const void*)hashB, 32, (const void*)hashB, 32, 1, 8, 8);
|
||||
LYRA2((void*)hashA, 32, (void*)hashB, 32, (void*)hashB, 32, 1, 8, 8);
|
||||
|
||||
sph_skein256_init(&ctx_skein);
|
||||
sph_skein256_init(&ctx_skein);
|
||||
sph_skein256 (&ctx_skein, hashA, 32);
|
||||
sph_skein256_close(&ctx_skein, hashB);
|
||||
|
||||
|
|
@ -65,6 +64,6 @@ void lyra2re_hash(const char* input, char* output)
|
|||
sph_groestl256 (&ctx_groestl, hashB, 32);
|
||||
sph_groestl256_close(&ctx_groestl, hashA);
|
||||
|
||||
memcpy(output, hashA, 32);
|
||||
memcpy(output, hashA, 32);
|
||||
}
|
||||
|
||||
|
|
@ -7,7 +7,7 @@ extern "C" {
|
|||
|
||||
#include <stdint.h>
|
||||
|
||||
void lyra2re_hash(const char* input, char* output);
|
||||
void lyra2re_hash(const char* input, char* output, uint32_t len);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
79
stratum/algos/lyra2v2.c
Normal file
79
stratum/algos/lyra2v2.c
Normal file
|
|
@ -0,0 +1,79 @@
|
|||
/*-
|
||||
* Copyright 2009 Colin Percival, 2011 ArtForz, 2013 Neisklar, 2014 James Lovejoy
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. 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.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
|
||||
*
|
||||
* This file was originally written by Colin Percival as part of the Tarsnap
|
||||
* online backup system.
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include "../sha3/sph_blake.h"
|
||||
#include "../sha3/sph_cubehash.h"
|
||||
#include "../sha3/sph_keccak.h"
|
||||
#include "../sha3/sph_skein.h"
|
||||
#include "../sha3/sph_bmw.h"
|
||||
#include "Lyra2.h"
|
||||
|
||||
void lyra2v2_hash(const char* input, char* output, uint32_t len)
|
||||
{
|
||||
uint32_t hashA[8], hashB[8];
|
||||
|
||||
sph_blake256_context ctx_blake;
|
||||
sph_keccak256_context ctx_keccak;
|
||||
sph_cubehash256_context ctx_cubehash;
|
||||
sph_skein256_context ctx_skein;
|
||||
sph_bmw256_context ctx_bmw;
|
||||
|
||||
sph_blake256_init(&ctx_blake);
|
||||
sph_blake256(&ctx_blake, input, len); /* 80 */
|
||||
sph_blake256_close(&ctx_blake, hashA);
|
||||
|
||||
sph_keccak256_init(&ctx_keccak);
|
||||
sph_keccak256(&ctx_keccak, hashA, 32);
|
||||
sph_keccak256_close(&ctx_keccak, hashB);
|
||||
|
||||
sph_cubehash256_init(&ctx_cubehash);
|
||||
sph_cubehash256(&ctx_cubehash, hashB, 32);
|
||||
sph_cubehash256_close(&ctx_cubehash, hashA);
|
||||
|
||||
LYRA2(hashB, 32, hashA, 32, hashA, 32, 1, 4, 4);
|
||||
|
||||
sph_skein256_init(&ctx_skein);
|
||||
sph_skein256(&ctx_skein, hashB, 32);
|
||||
sph_skein256_close(&ctx_skein, hashA);
|
||||
|
||||
sph_cubehash256_init(&ctx_cubehash);
|
||||
sph_cubehash256(&ctx_cubehash, hashA, 32);
|
||||
sph_cubehash256_close(&ctx_cubehash, hashB);
|
||||
|
||||
sph_bmw256_init(&ctx_bmw);
|
||||
sph_bmw256(&ctx_bmw, hashB, 32);
|
||||
sph_bmw256_close(&ctx_bmw, hashA);
|
||||
|
||||
memcpy(output, hashA, 32);
|
||||
}
|
||||
|
||||
16
stratum/algos/lyra2v2.h
Normal file
16
stratum/algos/lyra2v2.h
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
#ifndef LYRA2VE_H
|
||||
#define LYRA2VE_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
void lyra2v2_hash(const char* input, char* output, uint32_t len);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -7,7 +7,7 @@ CC=gcc
|
|||
CFLAGS=-c -O3 -I /usr/include/mysql -march=native
|
||||
LDFLAGS=-O2
|
||||
|
||||
SOURCES=Lyra2RE.c Lyra2.c Sponge.c blake.c scrypt.c c11.c x11.c x13.c sha256.c keccak.c \
|
||||
SOURCES=lyra2re.c lyra2v2.c Lyra2.c Sponge.c blake.c scrypt.c c11.c x11.c x13.c sha256.c keccak.c \
|
||||
x14.c x15.c nist5.c fresh.c quark.c neoscrypt.c scryptn.c qubit.c skein.c groestl.c \
|
||||
skein2.c zr5.c drop.c bmw.c
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
[TCP]
|
||||
server = yaamp.com
|
||||
port = 4533
|
||||
port = 5733
|
||||
password = tu8tu5
|
||||
|
||||
[SQL]
|
||||
|
|
|
|||
16
stratum/config.sample/lyra2v2.conf
Normal file
16
stratum/config.sample/lyra2v2.conf
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
[TCP]
|
||||
server = yaamp.com
|
||||
port = 4533
|
||||
password = tu8tu5
|
||||
|
||||
[SQL]
|
||||
host = yaampdb
|
||||
database = yaamp
|
||||
username = root
|
||||
password = patofpaq
|
||||
|
||||
[STRATUM]
|
||||
algo = lyra2v2
|
||||
difficulty = 1
|
||||
max_ttf = 40000
|
||||
|
||||
|
|
@ -79,11 +79,6 @@ static void neoscrypt_hash(const char* input, char* output, uint32_t len)
|
|||
neoscrypt((unsigned char *)input, (unsigned char *)output, 0x80000620);
|
||||
}
|
||||
|
||||
static void lyra2_hash(const char* input, char* output, uint32_t len)
|
||||
{
|
||||
lyra2re_hash(input, output);
|
||||
}
|
||||
|
||||
YAAMP_ALGO g_algos[] =
|
||||
{
|
||||
{"sha256", sha256_double_hash, 1, 0, 0},
|
||||
|
|
@ -97,7 +92,9 @@ YAAMP_ALGO g_algos[] =
|
|||
{"x14", x14_hash, 1, 0, 0},
|
||||
{"x15", x15_hash, 1, 0, 0},
|
||||
|
||||
{"lyra2", lyra2_hash, 0x80, 0, 0},
|
||||
{"lyra2", lyra2re_hash, 0x80, 0, 0},
|
||||
{"lyra2v2", lyra2v2_hash, 0x80, 0, 0},
|
||||
|
||||
{"blake", blake_hash, 1, 0, 0},
|
||||
{"fresh", fresh_hash, 0x100, 0, 0},
|
||||
{"quark", quark_hash, 1, 0, 0},
|
||||
|
|
|
|||
|
|
@ -130,7 +130,8 @@ void sha256_double_hash_hex(const char *input, char *output, unsigned int len);
|
|||
#include "algos/fresh.h"
|
||||
#include "algos/quark.h"
|
||||
#include "algos/neoscrypt.h"
|
||||
#include "algos/Lyra2RE.h"
|
||||
#include "algos/lyra2re.h"
|
||||
#include "algos/lyra2v2.h"
|
||||
#include "algos/blake.h"
|
||||
#include "algos/qubit.h"
|
||||
#include "algos/groestl.h"
|
||||
|
|
|
|||
|
|
@ -7,8 +7,9 @@ function yaamp_get_algos()
|
|||
'sha256',
|
||||
'scrypt',
|
||||
'scryptn',
|
||||
'neoscrypt',
|
||||
'lyra2',
|
||||
'lyra2v2',
|
||||
'neoscrypt',
|
||||
'quark',
|
||||
'qubit',
|
||||
'c11',
|
||||
|
|
@ -18,7 +19,6 @@ function yaamp_get_algos()
|
|||
'groestl', // dmd-gr -m 256
|
||||
'skein',
|
||||
'skein2',
|
||||
'bmw',
|
||||
'drop',
|
||||
'zr5',
|
||||
);
|
||||
|
|
@ -39,6 +39,7 @@ function yaamp_get_algo_norm($algo)
|
|||
'nist5' => 16,
|
||||
'neoscrypt' => 0.3,
|
||||
'lyra2' => 1.3,
|
||||
'lyra2v2' => 1.3,
|
||||
'quark' => 5,
|
||||
'fresh' => 5,
|
||||
'qubit' => 5,
|
||||
|
|
@ -48,8 +49,6 @@ function yaamp_get_algo_norm($algo)
|
|||
'keccak' => 160,
|
||||
'skein2' => 300,
|
||||
'zr5' => 5.5,
|
||||
'drop' => 1.5,
|
||||
'bmw' => 100,
|
||||
);
|
||||
|
||||
if(!isset($a[$algo]))
|
||||
|
|
@ -74,11 +73,11 @@ function getAlgoColors($algo)
|
|||
'quark' => '#c0c0c0',
|
||||
'qubit' => '#d0a0f0',
|
||||
'lyra2' => '#80a0f0',
|
||||
'lyra2v2' => '#80c0f0',
|
||||
'skein' => '#80a0a0',
|
||||
'skein2' => '#a0a0a0',
|
||||
'zr5' => '#d0b0d0',
|
||||
'drop' => '#d0b0d0',
|
||||
'bmw' => '#a0a0a0',
|
||||
'zr5' => '#d0b0d0',
|
||||
|
||||
'MN' => '#ffffff', // MasterNode Earnings
|
||||
'PoS' => '#ffffff' // Stake
|
||||
|
|
@ -106,7 +105,7 @@ function getAlgoPort($algo)
|
|||
'neoscrypt' => 4233,
|
||||
'scryptn' => 4333,
|
||||
'lyra2' => 4433,
|
||||
'blake' => 4533,
|
||||
'lyra2v2' => 4533,
|
||||
'jha' => 4633,
|
||||
'qubit' => 4733,
|
||||
'zr5' => 4833,
|
||||
|
|
@ -116,7 +115,8 @@ function getAlgoPort($algo)
|
|||
'skein2' => 5233,
|
||||
'groestl' => 5333,
|
||||
'zr5' => 5533,
|
||||
'bmw' => 5633,
|
||||
// 5555 to 5683 reserved
|
||||
'blake' => 5733,
|
||||
);
|
||||
|
||||
if(!isset($a[$algo]))
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue