void bitblock_hash(const char* input, char* output)
{
sph_shavite512_context ctx_shavite1;
sph_simd512_context ctx_simd1;
sph_echo512_context ctx_echo1;
//these uint512 in the c++ source of the client are backed by an array of uint32
uint32_t hashA[16], hashB[16];
sph_shavite512_init (&ctx_shavite1);
sph_shavite512 (&ctx_shavite1, input, 80);
sph_shavite512_close(&ctx_shavite1, hashA);
sph_simd512_init (&ctx_simd1);
sph_simd512 (&ctx_simd1, hashA, 64);
sph_simd512_close(&ctx_simd1, hashB);
sph_shavite512_init (&ctx_shavite1);
sph_shavite512 (&ctx_shavite1, hashB, 64);
sph_shavite512_close(&ctx_shavite1, hashA);
sph_simd512_init (&ctx_simd1);
sph_simd512 (&ctx_simd1, hashA, 64);
sph_simd512_close(&ctx_simd1, hashB);
sph_echo512_init (&ctx_echo1);
sph_echo512 (&ctx_echo1, hashB, 64);
sph_echo512_close(&ctx_echo1, hashA);
memcpy(output, hashA, 32);
}
extern void inkhash(void *state, const void *input)
{
sph_shavite512_context ctx_shavite;
uint32_t hash[16];
sph_shavite512_init(&ctx_shavite);
sph_shavite512 (&ctx_shavite, (const void*) input, 80);
sph_shavite512_close(&ctx_shavite, (void*) hash);
sph_shavite512_init(&ctx_shavite);
sph_shavite512(&ctx_shavite, (const void*) hash, 64);
sph_shavite512_close(&ctx_shavite, (void*) hash);
memcpy(state, hash, 32);
/*
int ii;
printf("result: ");
for (ii=0; ii < 32; ii++)
{
printf ("%.2x",((uint8_t*)state)[ii]);
};
printf ("\n");
*/
}
inline void freshhash(void* output, const void* input, uint32_t len)
{
unsigned char hash[128]; // uint32_t hashA[16], hashB[16];
#define hashA hash
#define hashB hash+64
memset(hash, 0, 128);
sph_shavite512_context ctx_shavite1;
sph_simd512_context ctx_simd1;
sph_echo512_context ctx_echo1;
sph_shavite512_init(&ctx_shavite1);
sph_shavite512(&ctx_shavite1, input, len);
sph_shavite512_close(&ctx_shavite1, hashA);
sph_simd512_init(&ctx_simd1);
sph_simd512(&ctx_simd1, hashA, 64);
sph_simd512_close(&ctx_simd1, hashB);
sph_shavite512_init(&ctx_shavite1);
sph_shavite512(&ctx_shavite1, hashB, 64);
sph_shavite512_close(&ctx_shavite1, hashA);
sph_simd512_init(&ctx_simd1);
sph_simd512(&ctx_simd1, hashA, 64);
sph_simd512_close(&ctx_simd1, hashB);
sph_echo512_init(&ctx_echo1);
sph_echo512(&ctx_echo1, hashB, 64);
sph_echo512_close(&ctx_echo1, hashA);
memcpy(output, hash, 32);
}
static
#endif
void freshHash(void *state, const void *input)
{
init_freshHash_contexts();
FreshHash_context_holder ctx;
uint32_t hashA[16], hashB[16];
//shavite-simd-shavite-simd-echo
memcpy(&ctx, &base_contexts, sizeof(base_contexts));
sph_shavite512 (&ctx.shavite1, input, 80);
sph_shavite512_close(&ctx.shavite1, hashA);
sph_simd512 (&ctx.simd1, hashA, 64);
sph_simd512_close(&ctx.simd1, hashB);
sph_shavite512 (&ctx.shavite2,hashB, 64);
sph_shavite512_close(&ctx.shavite2, hashA);
sph_simd512 (&ctx.simd2, hashA, 64);
sph_simd512_close(&ctx.simd2, hashB);
sph_echo512 (&ctx.echo1, hashB, 64);
sph_echo512_close(&ctx.echo1, hashA);
memcpy(state, hashA, 32);
}
void veltor_4way_hash( void *output, const void *input )
{
uint64_t hash0[8] __attribute__ ((aligned (64)));
uint64_t hash1[8] __attribute__ ((aligned (64)));
uint64_t hash2[8] __attribute__ ((aligned (64)));
uint64_t hash3[8] __attribute__ ((aligned (64)));
uint64_t vhash[8*4] __attribute__ ((aligned (64)));
veltor_4way_ctx_holder ctx __attribute__ ((aligned (64)));
memcpy( &ctx, &veltor_4way_ctx, sizeof(veltor_4way_ctx) );
skein512_4way( &ctx.skein, input, 80 );
skein512_4way_close( &ctx.skein, vhash );
mm256_deinterleave_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
sph_shavite512( &ctx.shavite, hash0, 64 );
sph_shavite512_close( &ctx.shavite, hash0 );
sph_shavite512_init( &ctx.shavite );
sph_shavite512( &ctx.shavite, hash1, 64 );
sph_shavite512_close( &ctx.shavite, hash1 );
sph_shavite512_init( &ctx.shavite );
sph_shavite512( &ctx.shavite, hash2, 64 );
sph_shavite512_close( &ctx.shavite, hash2 );
sph_shavite512_init( &ctx.shavite );
sph_shavite512( &ctx.shavite, hash3, 64 );
sph_shavite512_close( &ctx.shavite, hash3 );
mm_interleave_4x32( vhash, hash0, hash1, hash2, hash3, 512 );
shabal512_4way( &ctx.shabal, vhash, 64 );
shabal512_4way_close( &ctx.shabal, vhash );
mm_deinterleave_4x32( hash0, hash1, hash2, hash3, vhash, 512 );
sph_gost512( &ctx.gost, hash0, 64 );
sph_gost512_close( &ctx.gost, hash0 );
sph_gost512_init( &ctx.gost );
sph_gost512( &ctx.gost, hash1, 64 );
sph_gost512_close( &ctx.gost, hash1 );
sph_gost512_init( &ctx.gost );
sph_gost512( &ctx.gost, hash2, 64 );
sph_gost512_close( &ctx.gost, hash2 );
sph_gost512_init( &ctx.gost );
sph_gost512( &ctx.gost, hash3, 64 );
sph_gost512_close( &ctx.gost, hash3 );
memcpy( output, hash0, 32 );
memcpy( output+32, hash1, 32 );
memcpy( output+64, hash2, 32 );
memcpy( output+96, hash3, 32 );
}
void shavite3_hash(const char* input, char* output, uint32_t len)
{
char hash1[64];
char hash2[64];
sph_shavite512_context ctx_shavite;
sph_shavite512_init(&ctx_shavite);
sph_shavite512(&ctx_shavite, (const void*) input, len);
sph_shavite512_close(&ctx_shavite, (void*) &hash1);
sph_shavite512(&ctx_shavite, (const void*) &hash1, 64);
sph_shavite512_close(&ctx_shavite, (void*) &hash2);
memcpy(output, &hash2, 32);
}
inline void qhash(void *state, const void *input)
{
init_Qhash_contexts();
Qhash_context_holder ctx;
uint32_t hashA[16], hashB[16];
//luffa-cubehash-shivite-simd-echo
memcpy(&ctx, &base_contexts, sizeof(base_contexts));
sph_luffa512 (&ctx.luffa1, input, 80);
sph_luffa512_close (&ctx.luffa1, hashA);
sph_cubehash512 (&ctx.cubehash1, hashA, 64);
sph_cubehash512_close(&ctx.cubehash1, hashB);
sph_shavite512 (&ctx.shavite1, hashB, 64);
sph_shavite512_close(&ctx.shavite1, hashA);
sph_simd512 (&ctx.simd1, hashA, 64);
sph_simd512_close(&ctx.simd1, hashB);
sph_echo512 (&ctx.echo1, hashB, 64);
sph_echo512_close(&ctx.echo1, hashA);
memcpy(state, hashA, 32);
}
void veltorhash(void *output, const void *input)
{
// sph_skein512_context ctx_skein;
// sph_gost512_context ctx_gost;
// sph_shabal512_context ctx_shabal;
// sph_shavite512_context ctx_shavite;
//these uint512 in the c++ source of the client are backed by an array of uint32
uint32_t _ALIGN(64) hashA[16], hashB[16];
veltor_ctx_holder ctx;
memcpy( &ctx, &veltor_ctx, sizeof(veltor_ctx) );
// sph_skein512_init(&ctx_skein);
sph_skein512(&ctx.skein, input, 80);
sph_skein512_close(&ctx.skein, hashA);
// sph_shavite512_init(&ctx_shavite);
sph_shavite512(&ctx.shavite, hashA, 64);
sph_shavite512_close(&ctx.shavite, hashB);
// sph_shabal512_init(&ctx_shabal);
sph_shabal512(&ctx.shabal, hashB, 64);
sph_shabal512_close(&ctx.shabal, hashA);
// sph_gost512_init(&ctx_gost);
sph_gost512(&ctx.gost, hashA, 64);
sph_gost512_close(&ctx.gost, hashB);
memcpy(output, hashB, 32);
}
void qubithash(void *output, const void *input)
{
sph_luffa512_context ctx_luffa;
sph_cubehash512_context ctx_cubehash;
sph_shavite512_context ctx_shavite;
sph_simd512_context ctx_simd;
sph_echo512_context ctx_echo;
uint8_t hash[64];
sph_luffa512_init(&ctx_luffa);
sph_luffa512 (&ctx_luffa, input, 80);
sph_luffa512_close(&ctx_luffa, (void*) hash);
sph_cubehash512_init(&ctx_cubehash);
sph_cubehash512 (&ctx_cubehash, (const void*) hash, 64);
sph_cubehash512_close(&ctx_cubehash, (void*) hash);
sph_shavite512_init(&ctx_shavite);
sph_shavite512 (&ctx_shavite, (const void*) hash, 64);
sph_shavite512_close(&ctx_shavite, (void*) hash);
sph_simd512_init(&ctx_simd);
sph_simd512 (&ctx_simd, (const void*) hash, 64);
sph_simd512_close(&ctx_simd, (void*) hash);
sph_echo512_init(&ctx_echo);
sph_echo512 (&ctx_echo, (const void*) hash, 64);
sph_echo512_close(&ctx_echo, (void*) hash);
memcpy(output, hash, 32);
}
static
#endif
inline void inkhash(void *state, const void *input)
{
uint32_t hash[16];
sph_shavite512_context ctx_shavite;
sph_shavite512_init(&ctx_shavite);
sph_shavite512 (&ctx_shavite, input, 80);
sph_shavite512_close(&ctx_shavite, hash);
sph_shavite512_init(&ctx_shavite);
sph_shavite512(&ctx_shavite, hash, 64);
sph_shavite512_close(&ctx_shavite, hash);
memcpy(state, hash, 32);
}
inline void bitblockhash(void *state, const void *input)
{
init_Bhash_contexts();
Xhash_context_holder ctx;
uint32_t hashA[16], hashB[16];
memcpy(&ctx, &base_contexts, sizeof(base_contexts));
sph_blake512 (&ctx.blake1, input, 80);
sph_blake512_close (&ctx.blake1, hashA);
sph_bmw512 (&ctx.bmw1, hashA, 64);
sph_bmw512_close(&ctx.bmw1, hashB);
sph_groestl512 (&ctx.groestl1, hashB, 64);
sph_groestl512_close(&ctx.groestl1, hashA);
sph_skein512 (&ctx.skein1, hashA, 64);
sph_skein512_close(&ctx.skein1, hashB);
sph_jh512 (&ctx.jh1, hashB, 64);
sph_jh512_close(&ctx.jh1, hashA);
sph_keccak512 (&ctx.keccak1, hashA, 64);
sph_keccak512_close(&ctx.keccak1, hashB);
sph_luffa512 (&ctx.luffa1, hashB, 64);
sph_luffa512_close (&ctx.luffa1, hashA);
sph_cubehash512 (&ctx.cubehash1, hashA, 64);
sph_cubehash512_close(&ctx.cubehash1, hashB);
sph_shavite512 (&ctx.shavite1, hashB, 64);
sph_shavite512_close(&ctx.shavite1, hashA);
sph_simd512 (&ctx.simd1, hashA, 64);
sph_simd512_close(&ctx.simd1, hashB);
sph_echo512 (&ctx.echo1, hashB, 64);
sph_echo512_close(&ctx.echo1, hashA);
sph_hamsi512 (&ctx.hamsi1, hashA, 64);
sph_hamsi512_close(&ctx.hamsi1, hashB);
sph_fugue512 (&ctx.fugue1, hashB, 64);
sph_fugue512_close(&ctx.fugue1, hashA);
sph_shabal512 (&ctx.shabal1, (const unsigned char*)hashA, 64);
sph_shabal512_close(&ctx.shabal1, hashB);
sph_whirlpool (&ctx.whirlpool1, hashB, 64);
sph_whirlpool_close(&ctx.whirlpool1, hashA);
memcpy(state, hashA, 32);
}
void x15hash(void *output, const void *input)
{
uint32_t hash[16];
memset(hash, 0, 16 * sizeof(uint32_t));
sph_blake512(&ctx.blake, input, 80);
sph_blake512_close(&ctx.blake, hash);
sph_bmw512(&ctx.bmw, hash, 64);
sph_bmw512_close(&ctx.bmw, hash);
sph_groestl512(&ctx.groestl, hash, 64);
sph_groestl512_close(&ctx.groestl, hash);
sph_skein512(&ctx.skein, hash, 64);
sph_skein512_close(&ctx.skein, hash);
sph_jh512(&ctx.jh, hash, 64);
sph_jh512_close(&ctx.jh, hash);
sph_keccak512(&ctx.keccak, hash, 64);
sph_keccak512_close(&ctx.keccak, hash);
sph_luffa512(&ctx.luffa, hash, 64);
sph_luffa512_close(&ctx.luffa, hash);
sph_cubehash512(&ctx.cubehash, hash, 64);
sph_cubehash512_close(&ctx.cubehash, hash);
sph_shavite512(&ctx.shavite, hash, 64);
sph_shavite512_close(&ctx.shavite, hash);
sph_simd512(&ctx.simd, hash, 64);
sph_simd512_close(&ctx.simd, hash);
sph_echo512(&ctx.echo, hash, 64);
sph_echo512_close(&ctx.echo, hash);
sph_hamsi512(&ctx.hamsi, hash, 64);
sph_hamsi512_close(&ctx.hamsi, hash);
sph_fugue512(&ctx.fugue, hash, 64);
sph_fugue512_close(&ctx.fugue, hash);
sph_shabal512(&ctx.shabal, hash, 64);
sph_shabal512_close(&ctx.shabal, hash);
sph_whirlpool(&ctx.whirlpool, hash, 64);
sph_whirlpool_close(&ctx.whirlpool, hash);
memcpy(output, hash, 32);
}
void freshhash(void* output, const void* input)
{
uint32_t hash[16];
memset(hash, 0, 16 * sizeof(uint32_t));
sph_shavite512(&ctx.shavite, input, 80);
sph_shavite512_close(&ctx.shavite, hash);
sph_simd512(&ctx.simd, hash, 64);
sph_simd512_close(&ctx.simd, hash);
sph_shavite512(&ctx.shavite, hash, 64);
sph_shavite512_close(&ctx.shavite, hash);
sph_simd512(&ctx.simd, hash, 64);
sph_simd512_close(&ctx.simd, hash);
sph_echo512(&ctx.echo, hash, 64);
sph_echo512_close(&ctx.echo, hash);
memcpy(output, hash, 32);
}
static inline void xhash(void *state, const void *input)
{
init_Xhash_contexts();
Xhash_context_holder ctx;
uint32_t hashA[16], hashB[16];
//blake-bmw-groestl-sken-jh-meccak-luffa-cubehash-shivite-simd-echo
memcpy(&ctx, &base_contexts, sizeof(base_contexts));
sph_blake512 (&ctx.blake1, input, 80);
sph_blake512_close (&ctx.blake1, hashA);
sph_bmw512 (&ctx.bmw1, hashA, 64);
sph_bmw512_close(&ctx.bmw1, hashB);
sph_groestl512 (&ctx.groestl1, hashB, 64);
sph_groestl512_close(&ctx.groestl1, hashA);
sph_skein512 (&ctx.skein1, hashA, 64);
sph_skein512_close(&ctx.skein1, hashB);
sph_jh512 (&ctx.jh1, hashB, 64);
sph_jh512_close(&ctx.jh1, hashA);
sph_keccak512 (&ctx.keccak1, hashA, 64);
sph_keccak512_close(&ctx.keccak1, hashB);
sph_gost512 (&ctx.gost1, hashB, 64);
sph_gost512_close(&ctx.gost1, hashA);
sph_luffa512 (&ctx.luffa1, hashA, 64);
sph_luffa512_close (&ctx.luffa1, hashB);
sph_cubehash512 (&ctx.cubehash1, hashB, 64);
sph_cubehash512_close(&ctx.cubehash1, hashA);
sph_shavite512 (&ctx.shavite1, hashA, 64);
sph_shavite512_close(&ctx.shavite1, hashB);
sph_simd512 (&ctx.simd1, hashB, 64);
sph_simd512_close(&ctx.simd1, hashA);
sph_echo512 (&ctx.echo1, hashA, 64);
sph_echo512_close(&ctx.echo1, hashB);
memcpy(state, hashB, 32);
}
static void switchHash(const void *input, void *output, int id)
{
sph_keccak512_context ctx_keccak;
sph_blake512_context ctx_blake;
sph_groestl512_context ctx_groestl;
sph_skein512_context ctx_skein;
sph_luffa512_context ctx_luffa;
sph_echo512_context ctx_echo;
sph_simd512_context ctx_simd;
sph_cubehash512_context ctx_cubehash;
sph_fugue512_context ctx_fugue;
sph_shavite512_context ctx_shavite;
switch(id) {
case 0:
sph_keccak512_init(&ctx_keccak); sph_keccak512(&ctx_keccak, input, 64); sph_keccak512_close(&ctx_keccak, output);
break;
case 1:
sph_blake512_init(&ctx_blake); sph_blake512(&ctx_blake, input, 64); sph_blake512_close(&ctx_blake, output);
break;
case 2:
sph_groestl512_init(&ctx_groestl); sph_groestl512(&ctx_groestl, input, 64); sph_groestl512_close(&ctx_groestl, output);
break;
case 3:
sph_skein512_init(&ctx_skein); sph_skein512(&ctx_skein, input, 64); sph_skein512_close(&ctx_skein, output);
break;
case 4:
sph_luffa512_init(&ctx_luffa); sph_luffa512(&ctx_luffa, input, 64); sph_luffa512_close(&ctx_luffa, output);
break;
case 5:
sph_echo512_init(&ctx_echo); sph_echo512(&ctx_echo, input, 64); sph_echo512_close(&ctx_echo, output);
break;
case 6:
sph_shavite512_init(&ctx_shavite); sph_shavite512(&ctx_shavite, input, 64); sph_shavite512_close(&ctx_shavite, output);
break;
case 7:
sph_fugue512_init(&ctx_fugue); sph_fugue512(&ctx_fugue, input, 64); sph_fugue512_close(&ctx_fugue, output);
break;
case 8:
sph_simd512_init(&ctx_simd); sph_simd512(&ctx_simd, input, 64); sph_simd512_close(&ctx_simd, output);
break;
case 9:
sph_cubehash512_init(&ctx_cubehash); sph_cubehash512(&ctx_cubehash, input, 64); sph_cubehash512_close(&ctx_cubehash, output);
break;
default:
break;
}
}
inline void X11_Hash(const void *input, void *state)
{
init_X11_contexts();
X11_context_holder ctx;
uint32_t hashA[16], hashB[16];
//Order: Blake > Bmw > Groestl > Sken > Jh > Meccak > Luffa > Cubehash > Shivite > Simd > Echo
memcpy(&ctx, &base_contexts, sizeof(base_contexts));
sph_blake512 (&ctx.blake, input, 80);
sph_blake512_close (&ctx.blake, hashA);
sph_bmw512 (&ctx.bmw, hashA, 64);
sph_bmw512_close(&ctx.bmw, hashB);
sph_groestl512 (&ctx.groestl, hashB, 64);
sph_groestl512_close(&ctx.groestl, hashA);
sph_skein512 (&ctx.skein, hashA, 64);
sph_skein512_close(&ctx.skein, hashB);
sph_jh512 (&ctx.jh, hashB, 64);
sph_jh512_close(&ctx.jh, hashA);
sph_keccak512 (&ctx.keccak, hashA, 64);
sph_keccak512_close(&ctx.keccak, hashB);
sph_luffa512 (&ctx.luffa, hashB, 64);
sph_luffa512_close (&ctx.luffa, hashA);
sph_cubehash512 (&ctx.cubehash, hashA, 64);
sph_cubehash512_close(&ctx.cubehash, hashB);
sph_shavite512 (&ctx.shavite, hashB, 64);
sph_shavite512_close(&ctx.shavite, hashA);
sph_simd512 (&ctx.simd, hashA, 64);
sph_simd512_close(&ctx.simd, hashB);
sph_echo512 (&ctx.echo, hashB, 64);
sph_echo512_close(&ctx.echo, hashA);
memcpy(state, hashA, 32);
}
static void metishash(void *state, const void *input)
{
metishash_context_holder ctx;
uint32_t hashA[16], hashB[16];
//do one memcopy to get fresh contexts, its faster even with a larger block then issuing 9 memcopies
memcpy(&ctx, &base_contexts, sizeof(base_contexts));
sph_keccak512 (&ctx.keccak1, input, 80);
sph_keccak512_close (&ctx.keccak1, hashA);
sph_shavite512 (&ctx.shavite1, hashA, 64);
sph_shavite512_close(&ctx.shavite1, hashB);
sph_metis512 (&ctx.metis1, hashB, 64);
sph_metis512_close(&ctx.metis1, hashA);
memcpy(state, hashA, 32);
}
void metiscoin_process(minerMetiscoinBlock_t* block)
{
sph_keccak512_context ctx_keccak;
sph_shavite512_context ctx_shavite;
sph_metis512_context ctx_metis;
static unsigned char pblank[1];
block->nonce = 0;
uint32 target = *(uint32*)(block->targetShare+28);
uint64 hash0[8];
uint64 hash1[8];
uint64 hash2[8];
for(uint32 n=0; n<0x1000; n++)
{
if( block->height != monitorCurrentBlockHeight )
break;
for(uint32 f=0; f<0x8000; f++)
{
sph_keccak512_init(&ctx_keccak);
sph_shavite512_init(&ctx_shavite);
sph_metis512_init(&ctx_metis);
sph_keccak512(&ctx_keccak, &block->version, 80);
sph_keccak512_close(&ctx_keccak, hash0);
sph_shavite512(&ctx_shavite, hash0, 64);
sph_shavite512_close(&ctx_shavite, hash1);
sph_metis512(&ctx_metis, hash1, 64);
sph_metis512_close(&ctx_metis, hash2);
if( *(uint32*)((uint8*)hash2+28) <= target )
{
totalShareCount++;
xptMiner_submitShare(block);
}
block->nonce++;
}
totalCollisionCount += 0x8000;
}
}
void qubithash(void *output, const void *input)
{
unsigned char hash[128]; // uint32_t hashA[16], hashB[16];
#define hashB hash+64
qubit_ctx_holder ctx;
memcpy( &ctx, &qubit_ctx, sizeof(qubit_ctx) );
#ifdef LUFFA_SSE2_BROKEN
sph_luffa512 (&ctx.luffa, input, 80);
sph_luffa512_close(&ctx.luffa, (void*) hash);
#else
// init_luffa(&qubit_ctx.luffa,512);
update_luffa( &ctx.luffa, (const BitSequence*)input, 80 );
final_luffa( &ctx.luffa, (BitSequence*)hash);
#endif
cubehashUpdate( &ctx.cubehash, (const byte*) hash,64);
cubehashDigest( &ctx.cubehash, (byte*)hash);
sph_shavite512( &ctx.shavite, hash, 64);
sph_shavite512_close( &ctx.shavite, hash);
update_sd( &ctx.simd, (const BitSequence *)hash,512);
final_sd( &ctx.simd, (BitSequence *)hash);
#ifdef NO_AES_NI
sph_echo512 (&ctx.echo, (const void*) hash, 64);
sph_echo512_close(&ctx.echo, (void*) hash);
#else
update_echo ( &ctx.echo, (const BitSequence *) hash, 512);
final_echo( &ctx.echo, (BitSequence *) hash);
#endif
asm volatile ("emms");
memcpy(output, hash, 32);
}
static
#endif
inline void hmq1725hash(void *state, const void *input)
{
sph_blake512_context ctx_blake;
sph_bmw512_context ctx_bmw;
sph_groestl512_context ctx_groestl;
sph_jh512_context ctx_jh;
sph_keccak512_context ctx_keccak;
sph_skein512_context ctx_skein;
sph_luffa512_context ctx_luffa;
sph_cubehash512_context ctx_cubehash;
sph_shavite512_context ctx_shavite;
sph_simd512_context ctx_simd;
sph_echo512_context ctx_echo;
sph_hamsi512_context ctx_hamsi;
sph_fugue512_context ctx_fugue;
sph_shabal512_context ctx_shabal;
sph_whirlpool_context ctx_whirlpool;
sph_sha512_context ctx_sha2;
sph_haval256_5_context ctx_haval;
uint32_t mask = 24;
uint32_t zero = 0;
uint32_t hashA[16], hashB[16];
sph_bmw512_init(&ctx_bmw);
sph_bmw512 (&ctx_bmw, input, 80);
sph_bmw512_close (&ctx_bmw, hashA); //0
sph_whirlpool_init(&ctx_whirlpool);
sph_whirlpool (&ctx_whirlpool, hashA, 64); //0
sph_whirlpool_close(&ctx_whirlpool, hashB); //1
if ((hashB[0] & mask) != zero) //1
{
sph_groestl512_init(&ctx_groestl);
sph_groestl512 (&ctx_groestl, hashB, 64); //1
sph_groestl512_close(&ctx_groestl, hashA); //2
}
else
{
sph_skein512_init(&ctx_skein);
sph_skein512 (&ctx_skein, hashB, 64); //1
sph_skein512_close(&ctx_skein, hashA); //2
}
sph_jh512_init(&ctx_jh);
sph_jh512 (&ctx_jh, hashA, 64); //2
sph_jh512_close(&ctx_jh, hashB); //3
sph_keccak512_init(&ctx_keccak);
sph_keccak512 (&ctx_keccak, hashB, 64); //3
sph_keccak512_close(&ctx_keccak, hashA); //4
if ((hashA[0] & mask) != zero) //4
{
sph_blake512_init(&ctx_blake);
sph_blake512 (&ctx_blake, hashA, 64); //
sph_blake512_close(&ctx_blake, hashB); //5
}
else
{
sph_bmw512_init(&ctx_bmw);
sph_bmw512 (&ctx_bmw, hashA, 64); //4
sph_bmw512_close(&ctx_bmw, hashB); //5
}
sph_luffa512_init(&ctx_luffa);
sph_luffa512 (&ctx_luffa,hashB, 64); //5
sph_luffa512_close(&ctx_luffa, hashA); //6
sph_cubehash512_init(&ctx_cubehash);
sph_cubehash512 (&ctx_cubehash, hashA, 64); //6
sph_cubehash512_close(&ctx_cubehash, hashB); //7
if ((hashB[0] & mask) != zero) //7
{
sph_keccak512_init(&ctx_keccak);
sph_keccak512 (&ctx_keccak, hashB, 64); //
sph_keccak512_close(&ctx_keccak, hashA); //8
}
else
{
sph_jh512_init(&ctx_jh);
sph_jh512 (&ctx_jh, hashB, 64); //7
sph_jh512_close(&ctx_jh, hashA); //8
}
sph_shavite512_init(&ctx_shavite);
sph_shavite512 (&ctx_shavite,hashA, 64); //5
sph_shavite512_close(&ctx_shavite, hashB); //6
sph_simd512_init(&ctx_simd);
sph_simd512 (&ctx_simd, hashB, 64); //6
sph_simd512_close(&ctx_simd, hashA); //7
if ((hashA[0] & mask) != zero) //4
{
sph_whirlpool_init(&ctx_whirlpool);
sph_whirlpool (&ctx_whirlpool, hashA, 64); //
sph_whirlpool_close(&ctx_whirlpool, hashB); //5
}
else
{
sph_haval256_5_init(&ctx_haval);
sph_haval256_5 (&ctx_haval, hashA, 64); //4
sph_haval256_5_close(&ctx_haval, hashB); //5
memset(&hashB[8], 0, 32);
}
sph_echo512_init(&ctx_echo);
sph_echo512 (&ctx_echo,hashB, 64); //5
sph_echo512_close(&ctx_echo, hashA); //6
sph_blake512_init(&ctx_blake);
sph_blake512 (&ctx_blake, hashA, 64); //6
sph_blake512_close(&ctx_blake, hashB); //7
if ((hashB[0] & mask) != zero) //7
{
sph_shavite512_init(&ctx_shavite);
sph_shavite512 (&ctx_shavite, hashB, 64); //
sph_shavite512_close(&ctx_shavite, hashA); //8
}
else
{
sph_luffa512_init(&ctx_luffa);
sph_luffa512 (&ctx_luffa, hashB, 64); //7
sph_luffa512_close(&ctx_luffa, hashA); //8
}
sph_hamsi512_init(&ctx_hamsi);
sph_hamsi512 (&ctx_hamsi,hashA, 64); //5
sph_hamsi512_close(&ctx_hamsi, hashB); //6
sph_fugue512_init(&ctx_fugue);
sph_fugue512 (&ctx_fugue, hashB, 64); //6
sph_fugue512_close(&ctx_fugue, hashA); //7
if ((hashA[0] & mask) != zero) //4
{
sph_echo512_init(&ctx_echo);
sph_echo512 (&ctx_echo, hashA, 64); //
sph_echo512_close(&ctx_echo, hashB); //5
}
else
{
sph_simd512_init(&ctx_simd);
sph_simd512 (&ctx_simd, hashA, 64); //4
sph_simd512_close(&ctx_simd, hashB); //5
}
sph_shabal512_init(&ctx_shabal);
sph_shabal512 (&ctx_shabal,hashB, 64); //5
sph_shabal512_close(&ctx_shabal, hashA); //6
sph_whirlpool_init(&ctx_whirlpool);
sph_whirlpool (&ctx_whirlpool, hashA, 64); //6
sph_whirlpool_close(&ctx_whirlpool, hashB); //7
if ((hashB[0] & mask) != zero) //7
{
sph_fugue512_init(&ctx_fugue);
sph_fugue512 (&ctx_fugue, hashB, 64); //
sph_fugue512_close(&ctx_fugue, hashA); //8
}
else
{
sph_sha512_init(&ctx_sha2);
sph_sha512 (&ctx_sha2, hashB, 64); //7
sph_sha512_close(&ctx_sha2, hashA); //8
}
sph_groestl512_init(&ctx_groestl);
sph_groestl512 (&ctx_groestl,hashA, 64); //5
sph_groestl512_close(&ctx_groestl, hashB); //6
sph_sha512_init(&ctx_sha2);
sph_sha512 (&ctx_sha2, hashB, 64); //6
sph_sha512_close(&ctx_sha2, hashA); //7
if ((hashA[0] & mask) != zero) //4
{
sph_haval256_5_init(&ctx_haval);
sph_haval256_5 (&ctx_haval, hashA, 64); //
sph_haval256_5_close(&ctx_haval, hashB); //5
memset(&hashB[8], 0, 32);
}
else
{
sph_whirlpool_init(&ctx_whirlpool);
sph_whirlpool (&ctx_whirlpool, hashA, 64); //4
sph_whirlpool_close(&ctx_whirlpool, hashB); //5
}
sph_bmw512_init(&ctx_bmw);
sph_bmw512 (&ctx_bmw,hashB, 64); //5
sph_bmw512_close(&ctx_bmw, hashA); //6
memcpy(state, hashA, 32);
}
void X15_hash(const char* input, char* output)
{
sph_blake512_context ctx_blake;
sph_bmw512_context ctx_bmw;
sph_groestl512_context ctx_groestl;
sph_skein512_context ctx_skein;
sph_jh512_context ctx_jh;
sph_keccak512_context ctx_keccak;
sph_luffa512_context ctx_luffa1;
sph_cubehash512_context ctx_cubehash1;
sph_shavite512_context ctx_shavite1;
sph_simd512_context ctx_simd1;
sph_echo512_context ctx_echo1;
sph_hamsi512_context ctx_hamsi1;
sph_fugue512_context ctx_fugue1;
sph_shabal512_context ctx_shabal1;
sph_whirlpool_context ctx_whirlpool1;
//these uint512 in the c++ source of the client are backed by an array of uint32
uint32_t hashA[16], hashB[16];
sph_blake512_init(&ctx_blake);
sph_blake512 (&ctx_blake, input, 80);
sph_blake512_close (&ctx_blake, hashA);
sph_bmw512_init(&ctx_bmw);
sph_bmw512 (&ctx_bmw, hashA, 64);
sph_bmw512_close(&ctx_bmw, hashB);
sph_groestl512_init(&ctx_groestl);
sph_groestl512 (&ctx_groestl, hashB, 64);
sph_groestl512_close(&ctx_groestl, hashA);
sph_skein512_init(&ctx_skein);
sph_skein512 (&ctx_skein, hashA, 64);
sph_skein512_close (&ctx_skein, hashB);
sph_jh512_init(&ctx_jh);
sph_jh512 (&ctx_jh, hashB, 64);
sph_jh512_close(&ctx_jh, hashA);
sph_keccak512_init(&ctx_keccak);
sph_keccak512 (&ctx_keccak, hashA, 64);
sph_keccak512_close(&ctx_keccak, hashB);
sph_luffa512_init (&ctx_luffa1);
sph_luffa512 (&ctx_luffa1, hashB, 64);
sph_luffa512_close (&ctx_luffa1, hashA);
sph_cubehash512_init (&ctx_cubehash1);
sph_cubehash512 (&ctx_cubehash1, hashA, 64);
sph_cubehash512_close(&ctx_cubehash1, hashB);
sph_shavite512_init (&ctx_shavite1);
sph_shavite512 (&ctx_shavite1, hashB, 64);
sph_shavite512_close(&ctx_shavite1, hashA);
sph_simd512_init (&ctx_simd1);
sph_simd512 (&ctx_simd1, hashA, 64);
sph_simd512_close(&ctx_simd1, hashB);
sph_echo512_init (&ctx_echo1);
sph_echo512 (&ctx_echo1, hashB, 64);
sph_echo512_close(&ctx_echo1, hashA);
sph_hamsi512_init (&ctx_hamsi1);
sph_hamsi512 (&ctx_hamsi1, hashA, 64);
sph_hamsi512_close(&ctx_hamsi1, hashB);
sph_fugue512_init (&ctx_fugue1);
sph_fugue512 (&ctx_fugue1, hashB, 64);
sph_fugue512_close(&ctx_fugue1, hashA);
sph_shabal512_init (&ctx_shabal1);
sph_shabal512 (&ctx_shabal1, hashA, 64);
sph_shabal512_close(&ctx_shabal1, hashB);
sph_whirlpool_init (&ctx_whirlpool1);
sph_whirlpool (&ctx_whirlpool1, hashB, 64);
sph_whirlpool_close(&ctx_whirlpool1, hashA);
memcpy(output, hashA, 32);
}
inline void Xhash(void *state, const void *input)
{
Xhash_context_holder ctx;
// uint32_t hashA[16], hashB[16];
memcpy(&ctx, &base_contexts, sizeof(base_contexts));
#ifdef AES_NI_GR
init_groestl(&ctx.groestl);
#endif
DATA_ALIGNXY(unsigned char hashbuf[128],16);
size_t hashptr;
DATA_ALIGNXY(sph_u64 hashctA,8);
DATA_ALIGNXY(sph_u64 hashctB,8);
#ifndef AES_NI_GR
grsoState sts_grs;
#endif
DATA_ALIGNXY(unsigned char hash[128],16);
/* proably not needed */
memset(hash, 0, 128);
//blake1-bmw2-grs3-skein4-jh5-keccak6-luffa7-cubehash8-shavite9-simd10-echo11
//---blake1---
/* //blake init
blake512_init(&base_contexts.blake1, 512);
blake512_update(&ctx.blake1, input, 512);
blake512_final(&ctx.blake1, hash);
*/
DECL_BLK;
BLK_I;
BLK_W;
BLK_C;
//---bmw2---
DECL_BMW;
BMW_I;
BMW_U;
#define M(x) sph_dec64le_aligned(data + 8 * (x))
#define H(x) (h[x])
#define dH(x) (dh[x])
BMW_C;
#undef M
#undef H
#undef dH
//---grs3----
#ifdef AES_NI_GR
update_groestl(&ctx.groestl, (char*)hash,512);
final_groestl(&ctx.groestl, (char*)hash);
#else
GRS_I;
GRS_U;
GRS_C;
#endif
//---skein4---
DECL_SKN;
SKN_I;
SKN_U;
SKN_C;
//---jh5------
DECL_JH;
JH_H;
//---keccak6---
DECL_KEC;
KEC_I;
KEC_U;
KEC_C;
// asm volatile ("emms");
//--- luffa7
update_luffa(&ctx.luffa,(const BitSequence*)hash,512);
final_luffa(&ctx.luffa,(BitSequence*)hash+64);
//---cubehash---
cubehashUpdate(&ctx.cubehash,(const byte*) hash+64,64);
cubehashDigest(&ctx.cubehash,(byte*)hash);
//---shavite---
sph_shavite512 (&ctx.shavite1, hash, 64);
sph_shavite512_close(&ctx.shavite1, hash+64);
//sph_simd512 (&ctx.simd1, hashA, 64);
// sph_simd512_close(&ctx.simd1, hashB);
//-------simd512 vect128 --------------
update_sd(&ctx.ctx_simd1,(const BitSequence *)hash+64,512);
final_sd(&ctx.ctx_simd1,(BitSequence *)hash);
//---echo---
#ifdef AES_NI
update_echo (&ctx.echo1,(const BitSequence *) hash, 512);
final_echo(&ctx.echo1, (BitSequence *) hash+64);
#else
sph_echo512 (&ctx.echo1, hash, 64);
sph_echo512_close(&ctx.echo1, hash+64);
#endif
memcpy(state, hash+64, 32);
}
void x14hash(void *output, const void *input)
{
unsigned char hash[128]; // uint32_t hashA[16], hashB[16];
#define hashB hash+64
sph_blake512_context ctx_blake;
sph_bmw512_context ctx_bmw;
sph_groestl512_context ctx_groestl;
sph_jh512_context ctx_jh;
sph_keccak512_context ctx_keccak;
sph_skein512_context ctx_skein;
sph_luffa512_context ctx_luffa;
sph_cubehash512_context ctx_cubehash;
sph_shavite512_context ctx_shavite;
sph_simd512_context ctx_simd;
sph_echo512_context ctx_echo;
sph_hamsi512_context ctx_hamsi;
sph_fugue512_context ctx_fugue;
sph_shabal512_context ctx_shabal;
sph_blake512_init(&ctx_blake);
sph_blake512(&ctx_blake, input, 80);
sph_blake512_close(&ctx_blake, hash);
sph_bmw512_init(&ctx_bmw);
sph_bmw512(&ctx_bmw, hash, 64);
sph_bmw512_close(&ctx_bmw, hashB);
sph_groestl512_init(&ctx_groestl);
sph_groestl512(&ctx_groestl, hashB, 64);
sph_groestl512_close(&ctx_groestl, hash);
sph_skein512_init(&ctx_skein);
sph_skein512(&ctx_skein, hash, 64);
sph_skein512_close(&ctx_skein, hashB);
sph_jh512_init(&ctx_jh);
sph_jh512(&ctx_jh, hashB, 64);
sph_jh512_close(&ctx_jh, hash);
sph_keccak512_init(&ctx_keccak);
sph_keccak512(&ctx_keccak, hash, 64);
sph_keccak512_close(&ctx_keccak, hashB);
sph_luffa512_init(&ctx_luffa);
sph_luffa512(&ctx_luffa, hashB, 64);
sph_luffa512_close(&ctx_luffa, hash);
sph_cubehash512_init(&ctx_cubehash);
sph_cubehash512(&ctx_cubehash, hash, 64);
sph_cubehash512_close(&ctx_cubehash, hashB);
sph_shavite512_init(&ctx_shavite);
sph_shavite512(&ctx_shavite, hashB, 64);
sph_shavite512_close(&ctx_shavite, hash);
sph_simd512_init(&ctx_simd);
sph_simd512(&ctx_simd, hash, 64);
sph_simd512_close(&ctx_simd, hashB);
sph_echo512_init(&ctx_echo);
sph_echo512(&ctx_echo, hashB, 64);
sph_echo512_close(&ctx_echo, hash);
sph_hamsi512_init(&ctx_hamsi);
sph_hamsi512(&ctx_hamsi, hash, 64);
sph_hamsi512_close(&ctx_hamsi, hashB);
sph_fugue512_init(&ctx_fugue);
sph_fugue512(&ctx_fugue, hashB, 64);
sph_fugue512_close(&ctx_fugue, hash);
sph_shabal512_init(&ctx_shabal);
sph_shabal512(&ctx_shabal, hash, 64);
sph_shabal512_close(&ctx_shabal, hash);
memcpy(output, hash, 32);
}
void x12_4way_hash( void *state, const void *input )
{
uint64_t hash0[8] __attribute__ ((aligned (64)));
uint64_t hash1[8] __attribute__ ((aligned (64)));
uint64_t hash2[8] __attribute__ ((aligned (64)));
uint64_t hash3[8] __attribute__ ((aligned (64)));
uint64_t vhash[8*4] __attribute__ ((aligned (64)));
x12_4way_ctx_holder ctx;
memcpy( &ctx, &x12_4way_ctx, sizeof(x12_4way_ctx) );
// 1 Blake
blake512_4way( &ctx.blake, input, 80 );
blake512_4way_close( &ctx.blake, vhash );
// 2 Bmw
bmw512_4way( &ctx.bmw, vhash, 64 );
bmw512_4way_close( &ctx.bmw, vhash );
// Serial
mm256_deinterleave_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
// 3 Groestl
update_and_final_groestl( &ctx.groestl, (char*)hash0, (char*)hash0, 512 );
memcpy( &ctx.groestl, &x12_4way_ctx.groestl, sizeof(hashState_groestl) );
update_and_final_groestl( &ctx.groestl, (char*)hash1, (char*)hash1, 512 );
memcpy( &ctx.groestl, &x12_4way_ctx.groestl, sizeof(hashState_groestl) );
update_and_final_groestl( &ctx.groestl, (char*)hash2, (char*)hash2, 512 );
memcpy( &ctx.groestl, &x12_4way_ctx.groestl, sizeof(hashState_groestl) );
update_and_final_groestl( &ctx.groestl, (char*)hash3, (char*)hash3, 512 );
// Parallel 4way 64 bit
mm256_interleave_4x64( vhash, hash0, hash1, hash2, hash3, 512 );
// 4 Skein
skein512_4way( &ctx.skein, vhash, 64 );
skein512_4way_close( &ctx.skein, vhash );
// 5 JH
jh512_4way( &ctx.jh, vhash, 64 );
jh512_4way_close( &ctx.jh, vhash );
// 6 Keccak
keccak512_4way( &ctx.keccak, vhash, 64 );
keccak512_4way_close( &ctx.keccak, vhash );
// Serial
mm256_deinterleave_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
// 7 Luffa
mm256_interleave_2x128( vhash, hash0, hash1, 512 );
luffa_2way_update_close( &ctx.luffa, vhash, vhash, 64 );
mm256_deinterleave_2x128( hash0, hash1, vhash, 512 );
mm256_interleave_2x128( vhash, hash2, hash3, 512 );
luffa_2way_init( &ctx.luffa, 512 );
luffa_2way_update_close( &ctx.luffa, vhash, vhash, 64 );
mm256_deinterleave_2x128( hash2, hash3, vhash, 512 );
// 8 Cubehash
cubehashUpdateDigest( &ctx.cube, (byte*)hash0, (const byte*) hash0, 64 );
cubehashReinit( &ctx.cube );
cubehashUpdateDigest( &ctx.cube, (byte*)hash1, (const byte*) hash1, 64 );
cubehashReinit( &ctx.cube );
cubehashUpdateDigest( &ctx.cube, (byte*)hash2, (const byte*) hash2, 64 );
cubehashReinit( &ctx.cube );
cubehashUpdateDigest( &ctx.cube, (byte*)hash3, (const byte*) hash3, 64 );
// 9 Shavite
sph_shavite512( &ctx.shavite, hash0, 64 );
sph_shavite512_close( &ctx.shavite, hash0 );
memcpy( &ctx.shavite, &x12_4way_ctx.shavite,
sizeof(sph_shavite512_context) );
sph_shavite512( &ctx.shavite, hash1, 64 );
sph_shavite512_close( &ctx.shavite, hash1 );
memcpy( &ctx.shavite, &x12_4way_ctx.shavite,
sizeof(sph_shavite512_context) );
sph_shavite512( &ctx.shavite, hash2, 64 );
sph_shavite512_close( &ctx.shavite, hash2 );
memcpy( &ctx.shavite, &x12_4way_ctx.shavite,
sizeof(sph_shavite512_context) );
sph_shavite512( &ctx.shavite, hash3, 64 );
sph_shavite512_close( &ctx.shavite, hash3 );
// 10 Simd
mm256_interleave_2x128( vhash, hash0, hash1, 512 );
simd_2way_update_close( &ctx.simd, vhash, vhash, 512 );
mm256_deinterleave_2x128( hash0, hash1, vhash, 512 );
mm256_interleave_2x128( vhash, hash2, hash3, 512 );
simd_2way_init( &ctx.simd, 512 );
simd_2way_update_close( &ctx.simd, vhash, vhash, 512 );
mm256_deinterleave_2x128( hash2, hash3, vhash, 512 );
// 11 Echo
update_final_echo( &ctx.echo, (BitSequence *)hash0,
(const BitSequence *) hash0, 512 );
memcpy( &ctx.echo, &x12_4way_ctx.echo, sizeof(hashState_echo) );
update_final_echo( &ctx.echo, (BitSequence *)hash1,
(const BitSequence *) hash1, 512 );
memcpy( &ctx.echo, &x12_4way_ctx.echo, sizeof(hashState_echo) );
update_final_echo( &ctx.echo, (BitSequence *)hash2,
(const BitSequence *) hash2, 512 );
memcpy( &ctx.echo, &x12_4way_ctx.echo, sizeof(hashState_echo) );
update_final_echo( &ctx.echo, (BitSequence *)hash3,
(const BitSequence *) hash3, 512 );
// 12 Hamsi parallel 4way 32 bit
mm256_interleave_4x64( vhash, hash0, hash1, hash2, hash3, 512 );
hamsi512_4way( &ctx.hamsi, vhash, 64 );
hamsi512_4way_close( &ctx.hamsi, vhash );
mm256_deinterleave_4x64( state, state+32, state+64, state+96, vhash, 256 );
/*
// 13 Fugue serial
sph_fugue512( &ctx.fugue, hash0, 64 );
sph_fugue512_close( &ctx.fugue, hash0 );
memcpy( &ctx.fugue, &x13_4way_ctx.fugue, sizeof(sph_fugue512_context) );
sph_fugue512( &ctx.fugue, hash1, 64 );
sph_fugue512_close( &ctx.fugue, hash1 );
memcpy( &ctx.fugue, &x13_4way_ctx.fugue, sizeof(sph_fugue512_context) );
sph_fugue512( &ctx.fugue, hash2, 64 );
sph_fugue512_close( &ctx.fugue, hash2 );
memcpy( &ctx.fugue, &x13_4way_ctx.fugue, sizeof(sph_fugue512_context) );
sph_fugue512( &ctx.fugue, hash3, 64 );
sph_fugue512_close( &ctx.fugue, hash3 );
memcpy( state, hash0, 32 );
memcpy( state+32, hash1, 32 );
memcpy( state+64, hash2, 32 );
memcpy( state+96, hash3, 32 );
*/
}
static void x14hash(void *output, const void *input)
{
unsigned char hash[128]; // uint32_t hashA[16], hashB[16];
#define hashB hash+64
x14_ctx_holder ctx;
memcpy(&ctx, &x14_ctx, sizeof(x14_ctx));
#ifdef NO_AES_NI
grsoState sts_grs;
#endif
unsigned char hashbuf[128];
size_t hashptr;
sph_u64 hashctA;
sph_u64 hashctB;
//---blake1---
DECL_BLK;
BLK_I;
BLK_W;
BLK_C;
//---bmw2---
DECL_BMW;
BMW_I;
BMW_U;
#define M(x) sph_dec64le_aligned(data + 8 * (x))
#define H(x) (h[x])
#define dH(x) (dh[x])
BMW_C;
#undef M
#undef H
#undef dH
//---groestl----
#ifdef NO_AES_NI
// use SSE2 optimized GRS if possible
GRS_I;
GRS_U;
GRS_C;
// sph_groestl512 (&ctx.groestl, hash, 64);
// sph_groestl512_close(&ctx.groestl, hash);
#else
update_groestl( &ctx.groestl, (char*)hash,512);
final_groestl( &ctx.groestl, (char*)hash);
#endif
//---skein4---
DECL_SKN;
SKN_I;
SKN_U;
SKN_C;
//---jh5------
DECL_JH;
JH_H;
//---keccak6---
DECL_KEC;
KEC_I;
KEC_U;
KEC_C;
//--- luffa7
update_luffa( &ctx.luffa, (const BitSequence*)hash,512);
final_luffa( &ctx.luffa, (BitSequence*)hashB);
// 8 Cube
cubehashUpdate( &ctx.cubehash, (const byte*) hashB,64);
cubehashDigest( &ctx.cubehash, (byte*)hash);
// 9 Shavite
sph_shavite512( &ctx.shavite, hash, 64);
sph_shavite512_close( &ctx.shavite, hashB);
// 10 Simd
update_sd( &ctx.simd, (const BitSequence *)hashB,512);
final_sd( &ctx.simd, (BitSequence *)hash);
//11---echo---
#ifdef NO_AES_NI
sph_echo512(&ctx.echo, hash, 64);
sph_echo512_close(&ctx.echo, hashB);
#else
update_echo ( &ctx.echo, (const BitSequence *) hash, 512);
final_echo( &ctx.echo, (BitSequence *) hashB);
#endif
// X13 algos
// 12 Hamsi
sph_hamsi512(&ctx.hamsi, hashB, 64);
sph_hamsi512_close(&ctx.hamsi, hash);
// 13 Fugue
sph_fugue512(&ctx.fugue, hash, 64);
sph_fugue512_close(&ctx.fugue, hashB);
// X14 Shabal
sph_shabal512(&ctx.shabal, hashB, 64);
sph_shabal512_close(&ctx.shabal, hash);
asm volatile ("emms");
memcpy(output, hash, 32);
}
void x16r_hash(void* output, const void* input)
{
uint32_t _ALIGN(128) hash[64/4];
sph_blake512_context ctx_blake;
sph_bmw512_context ctx_bmw;
sph_groestl512_context ctx_groestl;
sph_skein512_context ctx_skein;
sph_jh512_context ctx_jh;
sph_keccak512_context ctx_keccak;
sph_luffa512_context ctx_luffa1;
sph_cubehash512_context ctx_cubehash1;
sph_shavite512_context ctx_shavite1;
sph_simd512_context ctx_simd1;
sph_echo512_context ctx_echo1;
sph_hamsi512_context ctx_hamsi1;
sph_fugue512_context ctx_fugue1;
sph_shabal512_context ctx_shabal1;
sph_whirlpool_context ctx_whirlpool1;
sph_sha512_context ctx_sha512;
void *in = (void*) input;
int size = 80;
if (s_ntime == UINT32_MAX) {
const uint8_t* in8 = (uint8_t*) input;
getAlgoString(&in8[4], hashOrder);
}
for (int i = 0; i < 16; i++)
{
const char elem = hashOrder[i];
const uint8_t algo = elem >= 'A' ? elem - 'A' + 10 : elem - '0';
switch (algo) {
case BLAKE:
sph_blake512_init(&ctx_blake);
sph_blake512(&ctx_blake, in, size);
sph_blake512_close(&ctx_blake, hash);
break;
case BMW:
sph_bmw512_init(&ctx_bmw);
sph_bmw512(&ctx_bmw, in, size);
sph_bmw512_close(&ctx_bmw, hash);
break;
case GROESTL:
sph_groestl512_init(&ctx_groestl);
sph_groestl512(&ctx_groestl, in, size);
sph_groestl512_close(&ctx_groestl, hash);
break;
case SKEIN:
sph_skein512_init(&ctx_skein);
sph_skein512(&ctx_skein, in, size);
sph_skein512_close(&ctx_skein, hash);
break;
case JH:
sph_jh512_init(&ctx_jh);
sph_jh512(&ctx_jh, in, size);
sph_jh512_close(&ctx_jh, hash);
break;
case KECCAK:
sph_keccak512_init(&ctx_keccak);
sph_keccak512(&ctx_keccak, in, size);
sph_keccak512_close(&ctx_keccak, hash);
break;
case LUFFA:
sph_luffa512_init(&ctx_luffa1);
sph_luffa512(&ctx_luffa1, in, size);
sph_luffa512_close(&ctx_luffa1, hash);
break;
case CUBEHASH:
sph_cubehash512_init(&ctx_cubehash1);
sph_cubehash512(&ctx_cubehash1, in, size);
sph_cubehash512_close(&ctx_cubehash1, hash);
break;
case SHAVITE:
sph_shavite512_init(&ctx_shavite1);
sph_shavite512(&ctx_shavite1, in, size);
sph_shavite512_close(&ctx_shavite1, hash);
break;
case SIMD:
sph_simd512_init(&ctx_simd1);
sph_simd512(&ctx_simd1, in, size);
sph_simd512_close(&ctx_simd1, hash);
break;
case ECHO:
sph_echo512_init(&ctx_echo1);
sph_echo512(&ctx_echo1, in, size);
sph_echo512_close(&ctx_echo1, hash);
break;
case HAMSI:
sph_hamsi512_init(&ctx_hamsi1);
sph_hamsi512(&ctx_hamsi1, in, size);
sph_hamsi512_close(&ctx_hamsi1, hash);
break;
case FUGUE:
sph_fugue512_init(&ctx_fugue1);
sph_fugue512(&ctx_fugue1, in, size);
sph_fugue512_close(&ctx_fugue1, hash);
break;
case SHABAL:
sph_shabal512_init(&ctx_shabal1);
sph_shabal512(&ctx_shabal1, in, size);
sph_shabal512_close(&ctx_shabal1, hash);
break;
case WHIRLPOOL:
sph_whirlpool_init(&ctx_whirlpool1);
sph_whirlpool(&ctx_whirlpool1, in, size);
sph_whirlpool_close(&ctx_whirlpool1, hash);
break;
case SHA512:
sph_sha512_init(&ctx_sha512);
sph_sha512(&ctx_sha512,(const void*) in, size);
sph_sha512_close(&ctx_sha512,(void*) hash);
break;
}
in = (void*) hash;
size = 64;
}
memcpy(output, hash, 32);
}
void x11evo_hash(void *output, const void *input)
{
uint32_t hash[64/4];
uint32_t len = 80;
sph_blake512_context ctx_blake;
sph_bmw512_context ctx_bmw;
sph_groestl512_context ctx_groestl;
sph_skein512_context ctx_skein;
sph_jh512_context ctx_jh;
sph_keccak512_context ctx_keccak;
sph_luffa512_context ctx_luffa1;
sph_cubehash512_context ctx_cubehash1;
sph_shavite512_context ctx_shavite1;
sph_simd512_context ctx_simd1;
sph_echo512_context ctx_echo1;
if (s_sequence == -1) {
uint32_t *data = (uint32_t*) input;
const uint32_t ntime = data[17];
evo_twisted_code(ntime, hashOrder);
}
void *in = (void*) input;
int size = len;
const int hashes = (int) strlen(hashOrder);
for (int i = 0; i < hashes; i++)
{
const char elem = hashOrder[i];
uint8_t algo = elem >= 'A' ? elem - 'A' + 10 : elem - '0';
if (i > 0) {
in = (void*) hash;
size = 64;
}
switch (algo) {
case BLAKE:
sph_blake512_init(&ctx_blake);
sph_blake512 (&ctx_blake, in, size);
sph_blake512_close (&ctx_blake, hash);
break;
case BMW:
sph_bmw512_init(&ctx_bmw);
sph_bmw512 (&ctx_bmw, in, size);
sph_bmw512_close(&ctx_bmw, hash);
break;
case GROESTL:
sph_groestl512_init(&ctx_groestl);
sph_groestl512 (&ctx_groestl, in, size);
sph_groestl512_close(&ctx_groestl, hash);
break;
case SKEIN:
sph_skein512_init(&ctx_skein);
sph_skein512 (&ctx_skein, in, size);
sph_skein512_close (&ctx_skein, hash);
break;
case JH:
sph_jh512_init(&ctx_jh);
sph_jh512 (&ctx_jh, in, size);
sph_jh512_close(&ctx_jh, hash);
break;
case KECCAK:
sph_keccak512_init(&ctx_keccak);
sph_keccak512 (&ctx_keccak, in, size);
sph_keccak512_close(&ctx_keccak, hash);
break;
case LUFFA:
sph_luffa512_init (&ctx_luffa1);
sph_luffa512 (&ctx_luffa1, in, size);
sph_luffa512_close (&ctx_luffa1, hash);
break;
case CUBEHASH:
sph_cubehash512_init (&ctx_cubehash1);
sph_cubehash512 (&ctx_cubehash1, in, size);
sph_cubehash512_close(&ctx_cubehash1, hash);
break;
case SHAVITE:
sph_shavite512_init (&ctx_shavite1);
sph_shavite512 (&ctx_shavite1, in, size);
sph_shavite512_close(&ctx_shavite1, hash);
break;
case SIMD:
sph_simd512_init (&ctx_simd1);
sph_simd512 (&ctx_simd1, in, size);
sph_simd512_close(&ctx_simd1, hash);
break;
case ECHO:
sph_echo512_init (&ctx_echo1);
sph_echo512 (&ctx_echo1, in, size);
sph_echo512_close(&ctx_echo1, hash);
break;
}
}
memcpy(output, hash, 32);
}