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); }
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); }
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); }
inline void sifhash(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; unsigned char hash[64]; sph_blake512_init(&ctx_blake); // ZBLAKE; sph_blake512 (&ctx_blake, input, 80); sph_blake512_close(&ctx_blake, (void*) hash); sph_bmw512_init(&ctx_bmw); // ZBMW; sph_bmw512 (&ctx_bmw, (const void*) hash, 64); sph_bmw512_close(&ctx_bmw, (void*) hash); sph_groestl512_init(&ctx_groestl); // ZGROESTL; sph_groestl512 (&ctx_groestl, (const void*) hash, 64); sph_groestl512_close(&ctx_groestl, (void*) hash); sph_jh512_init(&ctx_jh); // ZJH; sph_jh512 (&ctx_jh, (const void*) hash, 64); sph_jh512_close(&ctx_jh, (void*) hash); sph_keccak512_init(&ctx_keccak); // ZKECCAK; sph_keccak512 (&ctx_keccak, (const void*) hash, 64); sph_keccak512_close(&ctx_keccak, (void*) hash); sph_skein512_init(&ctx_skein); // SKEIN; sph_skein512 (&ctx_skein, (const void*) hash, 64); sph_skein512_close(&ctx_skein, (void*) hash); memcpy(state, 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); }
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); }
void quarkhash(void *state, const void *input) { uint32_t hash[16]; uint32_t mask = 8; uint32_t zero = 0; 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); if ((hash[0] & mask) != zero) { sph_groestl512(&ctx.groestl, hash, 64); sph_groestl512_close(&ctx.groestl, hash); } else { sph_skein512(&ctx.skein, hash, 64); sph_skein512_close(&ctx.skein, hash); } sph_groestl512(&ctx.groestl, hash, 64); sph_groestl512_close(&ctx.groestl, hash); sph_jh512(&ctx.jh, hash, 64); sph_jh512_close(&ctx.jh, hash); if ((hash[0] & mask) != zero) { sph_blake512(&ctx.blake, hash, 64); sph_blake512_close(&ctx.blake, hash); } else { sph_bmw512(&ctx.bmw, hash, 64); sph_bmw512_close(&ctx.bmw, hash); } sph_keccak512(&ctx.keccak, hash, 64); sph_keccak512_close(&ctx.keccak, hash); sph_skein512(&ctx.skein, hash, 64); sph_skein512_close(&ctx.skein, hash); if ((hash[0] & mask) != zero) { sph_keccak512(&ctx.keccak, hash, 64); sph_keccak512_close(&ctx.keccak, hash); } else { sph_jh512(&ctx.jh, hash, 64); sph_jh512_close(&ctx.jh, hash); } memcpy(state, hash, 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 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); }
static void quarkhash(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; // static unsigned char pblank[1]; quarkhash_context_holder ctx; uint32_t mask = 8; uint32_t zero = 0; //these uint512 in the c++ source of the client are backed by an array of uint32 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_blake512_init(&ctx.blake1); sph_blake512 (&ctx.blake1, input, 80); sph_blake512_close (&ctx.blake1, hashA); //0 // sph_bmw512_init(&ctx.bmw1); sph_bmw512 (&ctx.bmw1, hashA, 64); //0 sph_bmw512_close(&ctx.bmw1, hashB); //1 if ((hashB[0] & mask) != zero) //1 { // sph_groestl512_init(&ctx.groestl1); sph_groestl512 (&ctx.groestl1, hashB, 64); //1 sph_groestl512_close(&ctx.groestl1, hashA); //2 } else { // sph_skein512_init(&ctx.skein1); sph_skein512 (&ctx.skein1, hashB, 64); //1 sph_skein512_close(&ctx.skein1, hashA); //2 } // sph_groestl512_init(&ctx.groestl2); sph_groestl512 (&ctx.groestl2, hashA, 64); //2 sph_groestl512_close(&ctx.groestl2, hashB); //3 // sph_jh512_init(&ctx.jh1); sph_jh512 (&ctx.jh1, hashB, 64); //3 sph_jh512_close(&ctx.jh1, hashA); //4 if ((hashA[0] & mask) != zero) //4 { // sph_blake512_init(&ctx.blake2); sph_blake512 (&ctx.blake2, hashA, 64); // sph_blake512_close(&ctx.blake2, hashB); //5 } else { // sph_bmw512_init(&ctx.bmw2); sph_bmw512 (&ctx.bmw2, hashA, 64); //4 sph_bmw512_close(&ctx.bmw2, hashB); //5 } // sph_keccak512_init(&ctx.keccak1); sph_keccak512 (&ctx.keccak1, hashB, 64); //5 sph_keccak512_close(&ctx.keccak1, hashA); //6 // sph_skein512_init(&ctx.skein2); sph_skein512 (&ctx.skein2, hashA, 64); //6 sph_skein512_close(&ctx.skein2, hashB); //7 if ((hashB[0] & mask) != zero) //7 { // sph_keccak512_init(&ctx.keccak2); sph_keccak512 (&ctx.keccak2, hashB, 64); // sph_keccak512_close(&ctx.keccak2, hashA); //8 } else { // sph_jh512_init(&ctx.jh2); sph_jh512 (&ctx.jh2, hashB, 64); //7 sph_jh512_close(&ctx.jh2, hashA); //8 } memcpy(state, hashA, 32); /* int ii; printf("result: "); for (ii=0; ii < 32; ii++) { printf ("%.2x",((uint8_t*)state)[ii]); }; printf ("\n"); */ }