void heavycoin_hash(const char* input, int len, char* output) { unsigned char hash1[32]; HEFTY1((unsigned char *)input, len, hash1); /* HEFTY1 is new, so take an extra security measure to eliminate * the possiblity of collisions: * * Hash(x) = SHA256(x + HEFTY1(x)) * * N.B. '+' is concatenation. */ unsigned char hash2[32];; sha256_ctx ctx; sha256_init(&ctx); sha256_update(&ctx, (const unsigned char *)input, len); sha256_update(&ctx, hash1, sizeof(hash1)); sha256_final(&ctx, hash2); /* Additional security: Do not rely on a single cryptographic hash * function. Instead, combine the outputs of 4 of the most secure * cryptographic hash functions-- SHA256, KECCAK512, GROESTL512 * and BLAKE512. */ uint32_t hash3[16]; sph_keccak512_context keccakCtx; sph_keccak512_init(&keccakCtx); sph_keccak512(&keccakCtx, input, len); sph_keccak512(&keccakCtx, hash1, sizeof(hash1)); sph_keccak512_close(&keccakCtx, (void *)&hash3); uint32_t hash4[16]; sph_groestl512_context groestlCtx; sph_groestl512_init(&groestlCtx); sph_groestl512(&groestlCtx, input, len); sph_groestl512(&groestlCtx, hash1, sizeof(hash1)); sph_groestl512_close(&groestlCtx, (void *)&hash4); uint32_t hash5[16]; sph_blake512_context blakeCtx; sph_blake512_init(&blakeCtx); sph_blake512(&blakeCtx, input, len); sph_blake512(&blakeCtx, (unsigned char *)&hash1, sizeof(hash1)); sph_blake512_close(&blakeCtx, (void *)&hash5); uint32_t *final = (uint32_t *)output; combine_hashes(final, (uint32_t *)hash2, hash3, hash4, hash5); }
inline void nist5_hash(void *output, const void *input) { sph_blake512_context ctx_blake; sph_groestl512_context ctx_groestl; sph_skein512_context ctx_skein; sph_jh512_context ctx_jh; sph_keccak512_context ctx_keccak; uint32_t hash[16]; sph_blake512_init(&ctx_blake); sph_blake512 (&ctx_blake, input, 80); sph_blake512_close (&ctx_blake, hash); sph_groestl512_init(&ctx_groestl); sph_groestl512 (&ctx_groestl, hash, 64); sph_groestl512_close(&ctx_groestl, hash); sph_jh512_init(&ctx_jh); sph_jh512 (&ctx_jh, hash, 64); sph_jh512_close(&ctx_jh, hash); sph_keccak512_init(&ctx_keccak); sph_keccak512 (&ctx_keccak, hash, 64); sph_keccak512_close(&ctx_keccak, hash); sph_skein512_init(&ctx_skein); sph_skein512 (&ctx_skein, hash, 64); sph_skein512_close (&ctx_skein, hash); memcpy(output, hash, 32); }
void nist5_hash(const char* input, char* output) { sph_blake512_context ctx_blake; sph_groestl512_context ctx_groestl; sph_skein512_context ctx_skein; sph_jh512_context ctx_jh; sph_keccak512_context ctx_keccak; //these uint512 in the c++ source of the client are backed by an array of uint32 uint32_t hash[16]; sph_blake512_init(&ctx_blake); sph_blake512 (&ctx_blake, input, 80); sph_blake512_close (&ctx_blake, hash); sph_groestl512_init(&ctx_groestl); sph_groestl512 (&ctx_groestl, hash, 64); sph_groestl512_close(&ctx_groestl, hash); sph_jh512_init(&ctx_jh); sph_jh512 (&ctx_jh, hash, 64); sph_jh512_close(&ctx_jh, hash); sph_keccak512_init(&ctx_keccak); sph_keccak512 (&ctx_keccak, hash, 64); sph_keccak512_close(&ctx_keccak, hash); sph_skein512_init(&ctx_skein); sph_skein512 (&ctx_skein, hash, 64); sph_skein512_close (&ctx_skein, hash); memcpy(output, hash, 32); }
inline void nist5_hash(void *state, const void *input) { init_N5hash_contexts(); X5hash_context_holder ctx; uint32_t hashA[16], hashB[16]; //blake-bmw-groestl-sken-jh-meccak-luffa-cubehash-shivite-simd-echo memcpy(&ctx, &base_contexts5, sizeof(base_contexts5)); sph_blake512 (&ctx.blake1, input, 80); sph_blake512_close (&ctx.blake1, hashA); sph_groestl512 (&ctx.groestl1, hashA, 64); sph_groestl512_close(&ctx.groestl1, 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_skein512 (&ctx.skein1, hashB, 64); sph_skein512_close(&ctx.skein1, hashA); memcpy(state, hashA, 32); }
int heavycoin_scanhash(unsigned char* output, const unsigned char* input, int len) { DATA_ALIGN64(unsigned char hash1[32]); HEFTY1(input, len, hash1); DATA_ALIGN64(uint32_t hash5[16]); sph_blake512_context blakeCtx; sph_blake512_init(&blakeCtx); sph_blake512(&blakeCtx, input, len); sph_blake512(&blakeCtx, (unsigned char *)&hash1, sizeof(hash1)); sph_blake512_close(&blakeCtx, (void *)&hash5); if ((*((unsigned char *)hash5 + 31) & 0xF0) != 0) return 0; DATA_ALIGN64(unsigned char hash2[32]); SHA256_CTX ctx; SHA256_Init(&ctx); SHA256_Update(&ctx, input, len); SHA256_Update(&ctx, hash1, sizeof(hash1)); SHA256_Final(hash2, &ctx); if ((*((unsigned char *)hash2 + 31) & 0xF0) != 0) return 0; DATA_ALIGN64(uint32_t hash3[16]); sph_keccak512_context keccakCtx; sph_keccak512_init(&keccakCtx); sph_keccak512(&keccakCtx, input, len); sph_keccak512(&keccakCtx, hash1, sizeof(hash1)); sph_keccak512_close(&keccakCtx, (void *)&hash3); if ((*((unsigned char *)hash3 + 31) & 0xF0) != 0) return 0; DATA_ALIGN64(uint32_t hash4[16]); sph_groestl512_context groestlCtx; sph_groestl512_init(&groestlCtx); sph_groestl512(&groestlCtx, input, len); sph_groestl512(&groestlCtx, hash1, sizeof(hash1)); sph_groestl512_close(&groestlCtx, (void *)&hash4); if ((*((unsigned char *)hash4 + 31) & 0xF0) != 0) return 0; uint32_t *final = (uint32_t *)output; combine_hashes(final, (uint32_t *)hash2, hash3, hash4, hash5); return 1; }
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 jha_hash(void *output, const void *input) { uint8_t _ALIGN(128) hash[64]; #ifdef NO_AES_NI sph_groestl512_context ctx_groestl; #else hashState_groestl ctx_groestl; #endif sph_blake512_context ctx_blake; sph_jh512_context ctx_jh; sph_keccak512_context ctx_keccak; sph_skein512_context ctx_skein; memcpy( &ctx_keccak, &jha_kec_mid, sizeof jha_kec_mid ); sph_keccak512(&ctx_keccak, input+64, 16 ); sph_keccak512_close(&ctx_keccak, hash ); // Heavy & Light Pair Loop for (int round = 0; round < 3; round++) { if (hash[0] & 0x01) { #ifdef NO_AES_NI sph_groestl512_init(&ctx_groestl); sph_groestl512(&ctx_groestl, hash, 64 ); sph_groestl512_close(&ctx_groestl, hash ); #else init_groestl( &ctx_groestl, 64 ); update_and_final_groestl( &ctx_groestl, (char*)hash, (char*)hash, 512 ); #endif } else { sph_skein512_init(&ctx_skein); sph_skein512(&ctx_skein, hash, 64); sph_skein512_close(&ctx_skein, hash ); } if (hash[0] & 0x01) { sph_blake512_init(&ctx_blake); sph_blake512(&ctx_blake, hash, 64); sph_blake512_close(&ctx_blake, hash ); } else { sph_jh512_init(&ctx_jh); sph_jh512(&ctx_jh, hash, 64 ); sph_jh512_close(&ctx_jh, hash ); } } memcpy(output, hash, 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 heavy_hash(void* output, const void* input, int len) { uint32_t hash1[16], hash2[16], hash3[16], hash4[16], hash5[16]; HEFTY1(input, len, (unsigned char *)hash1); /* HEFTY1 is new, so take an extra security measure to eliminate * the possiblity of collisions: * * Hash(x) = SHA256(x + HEFTY1(x)) * * N.B. '+' is concatenation. */ SHA256_CTX sha256; SHA256_Init(&sha256); SHA256_Update(&sha256, input, len); SHA256_Update(&sha256, hash1, sizeof(hash1)); SHA256_Final((unsigned char*)hash2, &sha256); /* Additional security: Do not rely on a single cryptographic hash * function. Instead, combine the outputs of 4 of the most secure * cryptographic hash functions-- SHA256, KECCAK512, GROESTL512 * and BLAKE512. */ sph_keccak512(&ctx.keccak, input, len); sph_keccak512(&ctx.keccak, hash1, sizeof(hash1)); sph_keccak512_close(&ctx.keccak, hash3); sph_groestl512(&ctx.groestl, input, len); sph_groestl512(&ctx.groestl, hash1, sizeof(hash1)); sph_groestl512_close(&ctx.groestl, hash4); sph_blake512(&ctx.blake, input, len); sph_blake512(&ctx.blake, hash1, sizeof(hash1)); sph_blake512_close(&ctx.blake, hash5); combine_hashes((uint32_t *)output, hash2, hash3, hash4, hash5); }
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; } }
void jha_hash(const char* input, char* output, uint32_t len) { sph_blake512_context ctx_blake; sph_groestl512_context ctx_groestl; sph_jh512_context ctx_jh; sph_keccak512_context ctx_keccak; sph_skein512_context ctx_skein; uint32_t hash[16]; sph_keccak512_init(&ctx_keccak); sph_keccak512 (&ctx_keccak, input, 80); sph_keccak512_close(&ctx_keccak, (&hash)); // // Heavy & Light Pair Loop // unsigned int round; for (round = 0; round < 3; round++) { if (hash[0] & 0x01) { sph_groestl512_init(&ctx_groestl); sph_groestl512 (&ctx_groestl, (&hash), 64); sph_groestl512_close(&ctx_groestl, (&hash)); } else { sph_skein512_init(&ctx_skein); sph_skein512 (&ctx_skein, (&hash), 64); sph_skein512_close(&ctx_skein, (&hash)); } if (hash[0] & 0x01) { sph_blake512_init(&ctx_blake); sph_blake512 (&ctx_blake, (&hash), 64); sph_blake512_close(&ctx_blake, (&hash)); } else { sph_jh512_init(&ctx_jh); sph_jh512 (&ctx_jh, (&hash), 64); sph_jh512_close(&ctx_jh, (&hash)); } } memcpy(output, hash, 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 jha_hash(void *output, const void *input) { uint8_t _ALIGN(128) hash[64]; sph_blake512_context ctx_blake; sph_groestl512_context ctx_groestl; sph_jh512_context ctx_jh; sph_keccak512_context ctx_keccak; sph_skein512_context ctx_skein; // JHA v8 input is 80 bytes sph_keccak512_init(&ctx_keccak); sph_keccak512(&ctx_keccak, input, 80); sph_keccak512_close(&ctx_keccak, (&hash)); // Heavy & Light Pair Loop for (int round = 0; round < 3; round++) { if (hash[0] & 0x01) { sph_groestl512_init(&ctx_groestl); sph_groestl512(&ctx_groestl, (&hash), 64); sph_groestl512_close(&ctx_groestl, (&hash)); } else { sph_skein512_init(&ctx_skein); sph_skein512(&ctx_skein, (&hash), 64); sph_skein512_close(&ctx_skein, (&hash)); } if (hash[0] & 0x01) { sph_blake512_init(&ctx_blake); sph_blake512(&ctx_blake, (&hash), 64); sph_blake512_close(&ctx_blake, (&hash)); } else { sph_jh512_init(&ctx_jh); sph_jh512(&ctx_jh, (&hash), 64); sph_jh512_close(&ctx_jh, (&hash)); } } memcpy(output, hash, 32); }
static void jackpothash(void *state, const void *input) { sph_blake512_context ctx_blake; sph_groestl512_context ctx_groestl; sph_jh512_context ctx_jh; sph_keccak512_context ctx_keccak; sph_skein512_context ctx_skein; uint32_t hash[16]; sph_keccak512_init(&ctx_keccak); sph_keccak512 (&ctx_keccak, input, 80); sph_keccak512_close(&ctx_keccak, (&hash)); unsigned int round; for (round = 0; round < 3; round++) { if (hash[0] & 0x01) { sph_groestl512_init(&ctx_groestl); sph_groestl512 (&ctx_groestl, (&hash), 64); sph_groestl512_close(&ctx_groestl, (&hash)); } else { sph_skein512_init(&ctx_skein); sph_skein512 (&ctx_skein, (&hash), 64); sph_skein512_close(&ctx_skein, (&hash)); } if (hash[0] & 0x01) { sph_blake512_init(&ctx_blake); sph_blake512 (&ctx_blake, (&hash), 64); sph_blake512_close(&ctx_blake, (&hash)); } else { sph_jh512_init(&ctx_jh); sph_jh512 (&ctx_jh, (&hash), 64); sph_jh512_close(&ctx_jh, (&hash)); } } memcpy(state, hash, 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 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 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 void jackpothash_debug(void *state, const void *input) { sph_blake512_context ctx_blake; 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]; uint32_t hash[16]; int ii; unsigned char * ptr = (unsigned char *)input; printf("Input Hash : "); for (ii = 0; ii < 128; ii++) { printf("%.2x", ptr[ii]); } printf("\n"); sph_keccak512_init(&ctx_keccak); sph_keccak512 (&ctx_keccak, input, 80); sph_keccak512_close(&ctx_keccak, hash); ptr = (unsigned char *)(&hash[0]); printf("After keccak : "); for (ii = 0; ii < 64; ii++) { printf("%.2x", ptr[ii]); } printf("\n"); unsigned int round; for (round = 0; round < 3; round++) { if (hash[0] & 0x01) { sph_groestl512_init(&ctx_groestl); sph_groestl512 (&ctx_groestl, (&hash), 64); sph_groestl512_close(&ctx_groestl, (&hash)); } else { sph_skein512_init(&ctx_skein); sph_skein512 (&ctx_skein, (&hash), 64); sph_skein512_close(&ctx_skein, (&hash)); } if (hash[0] & 0x01) { sph_blake512_init(&ctx_blake); sph_blake512 (&ctx_blake, (&hash), 64); sph_blake512_close(&ctx_blake, (&hash)); } else { sph_jh512_init(&ctx_jh); sph_jh512 (&ctx_jh, (&hash), 64); sph_jh512_close(&ctx_jh, (&hash)); } unsigned char * ptr = (unsigned char *)(&hash[0]); int ii; printf("round %d : ", round); for (ii = 0; ii < 64; ii++) { printf("%.2x", (unsigned char)ptr[ii]); } printf("\n"); } memcpy(state, 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); }
int scanhash_m7m_hash(int thr_id, uint32_t *pdata, const uint32_t *ptarget, uint64_t max_nonce, unsigned long *hashes_done) { uint32_t data[32] __attribute__((aligned(128))); uint32_t *data_p64 = data + (M7_MIDSTATE_LEN / sizeof(data[0])); uint32_t hash[8] __attribute__((aligned(32))); uint8_t bhash[7][64] __attribute__((aligned(32))); uint32_t n = pdata[19] - 1; const uint32_t first_nonce = pdata[19]; char data_str[161], hash_str[65], target_str[65]; uint8_t *bdata = 0; mpz_t bns[8]; int rc = 0; int bytes, nnNonce2; mpz_t product; mpz_init(product); for(int i=0; i < 8; i++){ mpz_init(bns[i]); } memcpy(data, pdata, 80); sph_sha256_context ctx_final_sha256; sph_sha256_context ctx_sha256; sph_sha512_context ctx_sha512; sph_keccak512_context ctx_keccak; sph_whirlpool_context ctx_whirlpool; sph_haval256_5_context ctx_haval; sph_tiger_context ctx_tiger; sph_ripemd160_context ctx_ripemd; sph_sha256_init(&ctx_sha256); sph_sha256 (&ctx_sha256, data, M7_MIDSTATE_LEN); sph_sha512_init(&ctx_sha512); sph_sha512 (&ctx_sha512, data, M7_MIDSTATE_LEN); sph_keccak512_init(&ctx_keccak); sph_keccak512 (&ctx_keccak, data, M7_MIDSTATE_LEN); sph_whirlpool_init(&ctx_whirlpool); sph_whirlpool (&ctx_whirlpool, data, M7_MIDSTATE_LEN); sph_haval256_5_init(&ctx_haval); sph_haval256_5 (&ctx_haval, data, M7_MIDSTATE_LEN); sph_tiger_init(&ctx_tiger); sph_tiger (&ctx_tiger, data, M7_MIDSTATE_LEN); sph_ripemd160_init(&ctx_ripemd); sph_ripemd160 (&ctx_ripemd, data, M7_MIDSTATE_LEN); sph_sha256_context ctx2_sha256; sph_sha512_context ctx2_sha512; sph_keccak512_context ctx2_keccak; sph_whirlpool_context ctx2_whirlpool; sph_haval256_5_context ctx2_haval; sph_tiger_context ctx2_tiger; sph_ripemd160_context ctx2_ripemd; do { data[19] = ++n; nnNonce2 = (int)(data[19]/2); memset(bhash, 0, 7 * 64); ctx2_sha256 = ctx_sha256; sph_sha256 (&ctx2_sha256, data_p64, 80 - M7_MIDSTATE_LEN); sph_sha256_close(&ctx2_sha256, (void*)(bhash[0])); ctx2_sha512 = ctx_sha512; sph_sha512 (&ctx2_sha512, data_p64, 80 - M7_MIDSTATE_LEN); sph_sha512_close(&ctx2_sha512, (void*)(bhash[1])); ctx2_keccak = ctx_keccak; sph_keccak512 (&ctx2_keccak, data_p64, 80 - M7_MIDSTATE_LEN); sph_keccak512_close(&ctx2_keccak, (void*)(bhash[2])); ctx2_whirlpool = ctx_whirlpool; sph_whirlpool (&ctx2_whirlpool, data_p64, 80 - M7_MIDSTATE_LEN); sph_whirlpool_close(&ctx2_whirlpool, (void*)(bhash[3])); ctx2_haval = ctx_haval; sph_haval256_5 (&ctx2_haval, data_p64, 80 - M7_MIDSTATE_LEN); sph_haval256_5_close(&ctx2_haval, (void*)(bhash[4])); ctx2_tiger = ctx_tiger; sph_tiger (&ctx2_tiger, data_p64, 80 - M7_MIDSTATE_LEN); sph_tiger_close(&ctx2_tiger, (void*)(bhash[5])); ctx2_ripemd = ctx_ripemd; sph_ripemd160 (&ctx2_ripemd, data_p64, 80 - M7_MIDSTATE_LEN); sph_ripemd160_close(&ctx2_ripemd, (void*)(bhash[6])); for(int i=0; i < 7; i++){ set_one_if_zero(bhash[i]); mpz_set_uint512(bns[i],bhash[i]); } mpz_set_ui(bns[7],0); for(int i=0; i < 7; i++){ mpz_add(bns[7], bns[7], bns[i]); } mpz_set_ui(product,1); for(int i=0; i < 8; i++){ mpz_mul(product,product,bns[i]); } mpz_pow_ui(product, product, 2); bytes = mpz_sizeinbase(product, 256); bdata = (uint8_t *)realloc(bdata, bytes); mpz_export((void *)bdata, NULL, -1, 1, 0, 0, product); sph_sha256_init(&ctx_final_sha256); sph_sha256 (&ctx_final_sha256, bdata, bytes); sph_sha256_close(&ctx_final_sha256, (void*)(hash)); int digits=(int)((sqrt((double)(nnNonce2))*(1.+EPS))/9000+75); int iterations=20; mpf_set_default_prec((long int)(digits*BITS_PER_DIGIT+16)); mpz_t magipi; mpz_t magisw; mpf_t magifpi; mpf_t mpa1, mpb1, mpt1, mpp1; mpf_t mpa2, mpb2, mpt2, mpp2; mpf_t mpsft; mpz_init(magipi); mpz_init(magisw); mpf_init(magifpi); mpf_init(mpsft); mpf_init(mpa1); mpf_init(mpb1); mpf_init(mpt1); mpf_init(mpp1); mpf_init(mpa2); mpf_init(mpb2); mpf_init(mpt2); mpf_init(mpp2); uint32_t usw_; usw_ = sw_(nnNonce2, SW_DIVS); if (usw_ < 1) usw_ = 1; mpz_set_ui(magisw, usw_); uint32_t mpzscale=mpz_size(magisw); for(int i=0; i < NM7M; i++){ if (mpzscale > 1000) { mpzscale = 1000; } else if (mpzscale < 1) { mpzscale = 1; } mpf_set_ui(mpa1, 1); mpf_set_ui(mpb1, 2); mpf_set_d(mpt1, 0.25*mpzscale); mpf_set_ui(mpp1, 1); mpf_sqrt(mpb1, mpb1); mpf_ui_div(mpb1, 1, mpb1); mpf_set_ui(mpsft, 10); for(int j=0; j <= iterations; j++){ mpf_add(mpa2, mpa1, mpb1); mpf_div_ui(mpa2, mpa2, 2); mpf_mul(mpb2, mpa1, mpb1); mpf_abs(mpb2, mpb2); mpf_sqrt(mpb2, mpb2); mpf_sub(mpt2, mpa1, mpa2); mpf_abs(mpt2, mpt2); mpf_sqrt(mpt2, mpt2); mpf_mul(mpt2, mpt2, mpp1); mpf_sub(mpt2, mpt1, mpt2); mpf_mul_ui(mpp2, mpp1, 2); mpf_swap(mpa1, mpa2); mpf_swap(mpb1, mpb2); mpf_swap(mpt1, mpt2); mpf_swap(mpp1, mpp2); } mpf_add(magifpi, mpa1, mpb1); mpf_pow_ui(magifpi, magifpi, 2); mpf_div_ui(magifpi, magifpi, 4); mpf_abs(mpt1, mpt1); mpf_div(magifpi, magifpi, mpt1); mpf_pow_ui(mpsft, mpsft, digits/2); mpf_mul(magifpi, magifpi, mpsft); mpz_set_f(magipi, magifpi); mpz_add(product,product,magipi); mpz_add(product,product,magisw); mpz_set_uint256(bns[0], (void*)(hash)); mpz_add(bns[7], bns[7], bns[0]); mpz_mul(product,product,bns[7]); mpz_cdiv_q (product, product, bns[0]); if (mpz_sgn(product) <= 0) mpz_set_ui(product,1); bytes = mpz_sizeinbase(product, 256); mpzscale=bytes; bdata = (uint8_t *)realloc(bdata, bytes); mpz_export(bdata, NULL, -1, 1, 0, 0, product); sph_sha256_init(&ctx_final_sha256); sph_sha256 (&ctx_final_sha256, bdata, bytes); sph_sha256_close(&ctx_final_sha256, (void*)(hash)); } mpz_clear(magipi); mpz_clear(magisw); mpf_clear(magifpi); mpf_clear(mpsft); mpf_clear(mpa1); mpf_clear(mpb1); mpf_clear(mpt1); mpf_clear(mpp1); mpf_clear(mpa2); mpf_clear(mpb2); mpf_clear(mpt2); mpf_clear(mpp2); rc = fulltest_m7hash(hash, ptarget); if (rc) { if (opt_debug) { bin2hex(hash_str, (unsigned char *)hash, 32); bin2hex(target_str, (unsigned char *)ptarget, 32); bin2hex(data_str, (unsigned char *)data, 80); applog(LOG_DEBUG, "DEBUG: [%d thread] Found share!\ndata %s\nhash %s\ntarget %s", thr_id, data_str, hash_str, target_str); } pdata[19] = data[19]; goto out; } } while (n < max_nonce && !work_restart[thr_id].restart); pdata[19] = n; out: for(int i=0; i < 8; i++){ mpz_clear(bns[i]); } mpz_clear(product); free(bdata); *hashes_done = n - first_nonce + 1; return rc; }
short test_single_hash(uint8_t* input, unsigned len, uint8_t* expected, uint8_t algoIndex, unsigned * passedTestsPtr, unsigned * failedTestsPtr) { uint8_t output512[64]; unsigned i; char algorithms[][10] = {"Keccak", "Blake", "Groestl", "JH", "Skein" }; char * algoName = NULL; unsigned passed = 0; unsigned failed = 0; switch(algoIndex) { case KECCAK_ID: sph_keccak512_context ctx_keccak; // context for a Keccak hash sph_keccak512_init(&ctx_keccak); sph_keccak512 (&ctx_keccak, input, len); sph_keccak512_close(&ctx_keccak, output512); break; case BLAKE_ID: sph_blake512_context ctx_blake; // context for a Blake hash sph_blake512_init(&ctx_blake); sph_blake512(&ctx_blake, input, len); sph_blake512_close(&ctx_blake, output512); break; case GROESTL_ID: sph_groestl512_context ctx_groestl; // context for a Groestl hash sph_groestl512_init(&ctx_groestl); sph_groestl512(&ctx_groestl, input, len); sph_groestl512_close(&ctx_groestl, output512); break; case JH_ID: sph_jh512_context ctx_jh; // context for a JH hash sph_jh512_init(&ctx_jh); sph_jh512(&ctx_jh, input, len); sph_jh512_close(&ctx_jh, output512); break; case SKEIN_ID: sph_skein512_context ctx_skein; // context for a Skein hash sph_skein512_init(&ctx_skein); sph_skein512(&ctx_skein, input, len); sph_skein512_close(&ctx_skein, output512); break; default: return(0); } if(memcmp((void *)expected, (void *)output512, 64) == 0) passed += 1; else { failed += 1; #ifdef TEST_VERBOSELY printf("%s output did not match.\n", algoName); printf("%12s", "From input:\n"); for(i=0; i< len; i++) { printf("%02x", input[i]); } printf("\n"); printf("%12s", "Expected:\n"); for(i=0; i< 64; i++) { printf("%02x", expected[i]); } printf("\n"); printf("%12s", "But got:\n"); for(i=0; i< 64; i++) { printf("%02x", output512[i]); } printf("\n\n"); #endif // TEST_VERBOSELY } *passedTestsPtr += passed; *failedTestsPtr += failed; return(passed); }
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); }
static void advsha3_hash(void *state, const void *input) { sph_blake512_context ctx_blake; sph_groestl512_context ctx_groestl; sph_jh512_context ctx_jh; sph_keccak512_context ctx_keccak; sph_skein512_context ctx_skein; uint32_t hash[16]; if (opt_debughash) { unsigned char * ptr = (unsigned char *)input; int ii; printf("hash input : "); for (ii = 0; ii < 88; ii++) { printf("%.2x", (unsigned char)ptr[ii]); } printf("\n"); ptr = (unsigned char *)(&hash[0]); } sph_keccak512_init(&ctx_keccak); sph_keccak512 (&ctx_keccak, input, 88); sph_keccak512_close(&ctx_keccak, hash); if (opt_debughash) { unsigned char * ptr = (unsigned char *)(&hash[0]); int ii; printf("after keccak : "); for (ii = 0; ii < 64; ii++) { printf("%.2x", (unsigned char)ptr[ii]); } printf("\n"); } unsigned int round_mask = ( (unsigned int)(((unsigned char *)input)[84]) << 0 | (unsigned int)(((unsigned char *)input)[85]) << 8 | (unsigned int)(((unsigned char *)input)[86]) << 16 | (unsigned int)(((unsigned char *)input)[87]) << 24 ); unsigned int round_max = (hash[0] & round_mask); unsigned int round; unsigned int round_method; for (round = 0; round < round_max; round++) { round_method = hash[0] & 3; switch (round_method) { case 0: sph_blake512_init(&ctx_blake); sph_blake512 (&ctx_blake, hash, 64); sph_blake512_close(&ctx_blake, hash); break; case 1: sph_groestl512_init(&ctx_groestl); sph_groestl512 (&ctx_groestl, hash, 64); sph_groestl512_close(&ctx_groestl, hash); break; case 2: sph_jh512_init(&ctx_jh); sph_jh512 (&ctx_jh, hash, 64); sph_jh512_close(&ctx_jh, hash); break; case 3: sph_skein512_init(&ctx_skein); sph_skein512 (&ctx_skein, hash, 64); sph_skein512_close(&ctx_skein, hash); break; } if (opt_debughash) { unsigned char * ptr = (unsigned char *)(&hash[0]); int ii; printf("round %d method %d : ", round, round_method); for (ii = 0; ii < 64; ii++) { printf("%.2x", (unsigned char)ptr[ii]); } printf("\n"); } } memcpy(state, hash, 32); }
static void zr5hash(void *state, const void *input) { DATA_ALIGN16(unsigned char hashbuf[128]); DATA_ALIGN16(unsigned char hash[128]); DATA_ALIGN16(size_t hashptr); DATA_ALIGN16(sph_u64 hashctA); DATA_ALIGN16(sph_u64 hashctB); //memset(hash, 0, 128); #ifdef NO_AES_NI grsoState sts_grs; #endif static const int arrOrder[][4] = { { 0, 1, 2, 3 }, { 0, 1, 3, 2 }, { 0, 2, 1, 3 }, { 0, 2, 3, 1 }, { 0, 3, 1, 2 }, { 0, 3, 2, 1 }, { 1, 0, 2, 3 }, { 1, 0, 3, 2 }, { 1, 2, 0, 3 }, { 1, 2, 3, 0 }, { 1, 3, 0, 2 }, { 1, 3, 2, 0 }, { 2, 0, 1, 3 }, { 2, 0, 3, 1 }, { 2, 1, 0, 3 }, { 2, 1, 3, 0 }, { 2, 3, 0, 1 }, { 2, 3, 1, 0 }, { 3, 0, 1, 2 }, { 3, 0, 2, 1 }, { 3, 1, 0, 2 }, { 3, 1, 2, 0 }, { 3, 2, 0, 1 }, { 3, 2, 1, 0 } }; zr5_ctx_holder ctx; memcpy( &ctx, &zr5_ctx, sizeof(zr5_ctx) ); sph_keccak512 (&ctx.keccak, input, 80); sph_keccak512_close(&ctx.keccak, hash); unsigned int nOrder = *(unsigned int *)(&hash) % 24; unsigned int i = 0; for (i = 0; i < 4; i++) { switch (arrOrder[nOrder][i]) { case 0: {DECL_BLK; BLK_I; BLK_U; BLK_C;} break; case 1: #ifdef NO_AES_NI {GRS_I; GRS_U; GRS_C; } #else update_groestl( &ctx.groestl, (char*)hash,512); final_groestl( &ctx.groestl, (char*)hash); #endif break; case 2: {DECL_JH; JH_H;} break; case 3: {DECL_SKN; SKN_I; SKN_U; SKN_C; } break; default: break; } } asm volatile ("emms"); memcpy(state, hash, 32); }
void jha_kec_midstate( const void* input ) { sph_keccak512_init( &jha_kec_mid ); sph_keccak512( &jha_kec_mid, input, 64 ); }
int scanhash_m7hash(int thr_id, uint32_t *pdata, const uint32_t *ptarget, uint64_t max_nonce, unsigned long *hashes_done) { uint32_t data[32] __attribute__((aligned(128))); uint32_t *data_p64 = data + (M7_MIDSTATE_LEN / sizeof(data[0])); uint32_t hash[8] __attribute__((aligned(32))); uint8_t bhash[7][64] __attribute__((aligned(32))); uint32_t hashtest[8] __attribute__((aligned(32))); uint32_t n = pdata[29] - 1; const uint32_t first_nonce = pdata[29]; char data_str[245], hash_str[65], target_str[65]; uint8_t *bdata = 0; mpz_t bns[7]; int rc = 0; for(int i=0; i < 7; i++){ mpz_init(bns[i]); } memcpy(data, pdata, 122); sph_sha256_context ctx_final_sha256; sph_sha256_context ctx_sha256; sph_sha512_context ctx_sha512; sph_keccak512_context ctx_keccak; sph_whirlpool_context ctx_whirlpool; sph_haval256_5_context ctx_haval; sph_tiger_context ctx_tiger; sph_ripemd160_context ctx_ripemd; sph_sha256_init(&ctx_sha256); sph_sha256 (&ctx_sha256, data, M7_MIDSTATE_LEN); sph_sha512_init(&ctx_sha512); sph_sha512 (&ctx_sha512, data, M7_MIDSTATE_LEN); sph_keccak512_init(&ctx_keccak); sph_keccak512 (&ctx_keccak, data, M7_MIDSTATE_LEN); sph_whirlpool_init(&ctx_whirlpool); sph_whirlpool (&ctx_whirlpool, data, M7_MIDSTATE_LEN); sph_haval256_5_init(&ctx_haval); sph_haval256_5 (&ctx_haval, data, M7_MIDSTATE_LEN); sph_tiger_init(&ctx_tiger); sph_tiger (&ctx_tiger, data, M7_MIDSTATE_LEN); sph_ripemd160_init(&ctx_ripemd); sph_ripemd160 (&ctx_ripemd, data, M7_MIDSTATE_LEN); sph_sha256_context ctx2_sha256; sph_sha512_context ctx2_sha512; sph_keccak512_context ctx2_keccak; sph_whirlpool_context ctx2_whirlpool; sph_haval256_5_context ctx2_haval; sph_tiger_context ctx2_tiger; sph_ripemd160_context ctx2_ripemd; do { data[29] = ++n; memset(bhash, 0, 7 * 64); ctx2_sha256 = ctx_sha256; sph_sha256 (&ctx2_sha256, data_p64, 122 - M7_MIDSTATE_LEN); sph_sha256_close(&ctx2_sha256, (void*)(bhash[0])); ctx2_sha512 = ctx_sha512; sph_sha512 (&ctx2_sha512, data_p64, 122 - M7_MIDSTATE_LEN); sph_sha512_close(&ctx2_sha512, (void*)(bhash[1])); ctx2_keccak = ctx_keccak; sph_keccak512 (&ctx2_keccak, data_p64, 122 - M7_MIDSTATE_LEN); sph_keccak512_close(&ctx2_keccak, (void*)(bhash[2])); ctx2_whirlpool = ctx_whirlpool; sph_whirlpool (&ctx2_whirlpool, data_p64, 122 - M7_MIDSTATE_LEN); sph_whirlpool_close(&ctx2_whirlpool, (void*)(bhash[3])); ctx2_haval = ctx_haval; sph_haval256_5 (&ctx2_haval, data_p64, 122 - M7_MIDSTATE_LEN); sph_haval256_5_close(&ctx2_haval, (void*)(bhash[4])); ctx2_tiger = ctx_tiger; sph_tiger (&ctx2_tiger, data_p64, 122 - M7_MIDSTATE_LEN); sph_tiger_close(&ctx2_tiger, (void*)(bhash[5])); ctx2_ripemd = ctx_ripemd; sph_ripemd160 (&ctx2_ripemd, data_p64, 122 - M7_MIDSTATE_LEN); sph_ripemd160_close(&ctx2_ripemd, (void*)(bhash[6])); for(int i=0; i < 7; i++){ set_one_if_zero(bhash[i]); mpz_set_uint512(bns[i],bhash[i]); } for(int i=6; i > 0; i--){ mpz_mul(bns[i-1], bns[i-1], bns[i]); } int bytes = mpz_sizeinbase(bns[0], 256); bdata = (uint8_t *)realloc(bdata, bytes); mpz_export((void *)bdata, NULL, -1, 1, 0, 0, bns[0]); sph_sha256_init(&ctx_final_sha256); sph_sha256 (&ctx_final_sha256, bdata, bytes); sph_sha256_close(&ctx_final_sha256, (void*)(hash)); rc = fulltest_m7hash(hash, ptarget); if (rc) { if (opt_debug) { bin2hex(hash_str, (unsigned char *)hash, 32); bin2hex(target_str, (unsigned char *)ptarget, 32); bin2hex(data_str, (unsigned char *)data, 122); applog(LOG_DEBUG, "DEBUG: [%d thread] Found share!\ndata %s\nhash %s\ntarget %s", thr_id, data_str, hash_str, target_str); } pdata[29] = data[29]; goto out; } } while (n < max_nonce && !work_restart[thr_id].restart); pdata[29] = n; out: for(int i=0; i < 7; i++){ mpz_clear(bns[i]); } *hashes_done = n - first_nonce + 1; free(bdata); return rc; }