JNIEXPORT jbyteArray JNICALL Java_keccak_KeccakJNI_keccak_1sha3(JNIEnv *env, jobject thisObj, jbyteArray input)
{
jsize size = (*env) -> GetArrayLength (env, input);
unsigned char *myInput;
myInput = malloc(1 + size);
(*env) -> GetByteArrayRegion (env, input, 0, size, myInput);
sph_keccak256_context mc;
unsigned char *res = malloc(32);
size_t dbuf_len;
unsigned char *dbuf;
sph_keccak256_init(&mc);
sph_keccak256(&mc, myInput, size);
sph_keccak256_close(&mc, res);
jbyteArray jbyteResult = (*env) -> NewByteArray(env, 32);
(*env) -> SetByteArrayRegion (env, jbyteResult, 0, 32, (jbyte*)res);
free(myInput);
free(res);
return jbyteResult;
}
void lyra2_hash(void *state, const void *input)
{
sph_blake256_context ctx_blake;
sph_keccak256_context ctx_keccak;
sph_skein256_context ctx_skein;
sph_groestl256_context ctx_groestl;
uint32_t hashA[8], hashB[8];
sph_blake256_init(&ctx_blake);
sph_blake256(&ctx_blake, input, 80);
sph_blake256_close(&ctx_blake, hashA);
sph_keccak256_init(&ctx_keccak);
sph_keccak256(&ctx_keccak, hashA, 32);
sph_keccak256_close(&ctx_keccak, hashB);
LYRA2(hashA, 32, hashB, 32, hashB, 32, 1, 8, 8);
sph_skein256_init(&ctx_skein);
sph_skein256(&ctx_skein, hashA, 32);
sph_skein256_close(&ctx_skein, hashB);
sph_groestl256_init(&ctx_groestl);
sph_groestl256(&ctx_groestl, hashB, 32);
sph_groestl256_close(&ctx_groestl, hashA);
memcpy(state, hashA, 32);
}
void lyra2re_hash(void *state, const void *input)
{
lyra2re_ctx_holder ctx;
memcpy(&ctx, &lyra2re_ctx, sizeof(lyra2re_ctx));
// uint32_t _ALIGN(128) hashA[8], hashB[8];
uint32_t _ALIGN(128) hash[32];
#define hashA hash
#define hashB hash+16
sph_blake256(&ctx.blake, input, 80);
sph_blake256_close(&ctx.blake, hashA);
sph_keccak256(&ctx.keccak, hashA, 32);
sph_keccak256_close(&ctx.keccak, hashB);
LYRA2(hashA, 32, hashB, 32, hashB, 32, 1, 8, 8);
sph_skein256(&ctx.skein, hashA, 32);
sph_skein256_close(&ctx.skein, hashB);
#ifdef NO_AES_NI
sph_groestl256( &ctx.groestl, hashB, 32 );
sph_groestl256_close( &ctx.groestl, hashA );
#else
update_groestl256( &ctx.groestl, hashB, 256 );
final_groestl256( &ctx.groestl, hashA );
#endif
memcpy(state, hashA, 32);
}
void lyra2re_hash(const char* input, char* output)
{
sph_blake256_context ctx_blake;
sph_groestl256_context ctx_groestl;
sph_keccak256_context ctx_keccak;
sph_skein256_context ctx_skein;
uint32_t hashA[8], hashB[8];
sph_blake256_init(&ctx_blake);
sph_blake256 (&ctx_blake, input, 80);
sph_blake256_close (&ctx_blake, hashA);
sph_keccak256_init(&ctx_keccak);
sph_keccak256 (&ctx_keccak,hashA, 32);
sph_keccak256_close(&ctx_keccak, hashB);
LYRA2((void*)hashA, 32, (const void*)hashB, 32, (const void*)hashB, 32, 1, 8, 8);
sph_skein256_init(&ctx_skein);
sph_skein256 (&ctx_skein, hashA, 32);
sph_skein256_close(&ctx_skein, hashB);
sph_groestl256_init(&ctx_groestl);
sph_groestl256 (&ctx_groestl, hashB, 32);
sph_groestl256_close(&ctx_groestl, hashA);
memcpy(output, hashA, 32);
}
static void keccakhash(void *state, const void *input)
{
sph_keccak256_context ctx_keccak;
uint32_t hash[32];
sph_keccak256_init(&ctx_keccak);
sph_keccak256 (&ctx_keccak,input, 80);
sph_keccak256_close(&ctx_keccak, hash);
memcpy(state, hash, 32);
}
void keccakhash(void *output, const void *input)
{
uint32_t hash[16];
memset(hash, 0, 16 * sizeof(uint32_t));
sph_keccak256(&ctx.keccak, input, 80);
sph_keccak256_close(&ctx.keccak, hash);
memcpy(output, hash, 32);
}
hashval SHA3<256>::ComputeHash(const ConstBuf& mb) {
#if UCFG_IMP_SHA3=='S'
UInt32 hash[8];
sph_keccak256_context ctx;
sph_keccak256_init(&ctx);
sph_keccak256(&ctx, mb.P, mb.Size);
sph_keccak256_close(&ctx, hash);
return hashval((const byte*)hash, sizeof hash);
#else
Throw(E_NOTIMPL);
#endif
}
JNIEXPORT void JNICALL Java_keccak_KeccakJNI_keccak_1sha3_12
(JNIEnv *env, jobject thisObj, jobject input, jobject output, jint size){
jbyte* dInput = (*env)->GetDirectBufferAddress(env, input);
jbyte* dOutput = (*env)->GetDirectBufferAddress(env, output);
sph_keccak256_context mc;
sph_keccak256_init(&mc);
sph_keccak256(&mc, dInput, size);
sph_keccak256_close(&mc, dOutput);
}
void xptMiner_submitShare_test(minerMaxcoinBlock_t* block)
{
// debug method to check if share is 100% valid without server access
uint32* blockInputData = (uint32*)block;
uint64 hash0[4];
sph_keccak256_context ctx_keccak;
sph_keccak256_init(&ctx_keccak);
sph_keccak256(&ctx_keccak, blockInputData, 80);
sph_keccak256_close(&ctx_keccak, hash0);
if( (hash0[3]>>32) <= *(uint32*)(block->targetShare+32-4) )
{
printf("Share valid (nonce: %08x)\n", block->nonce);
}
else
{
inline void lyra2rev2hash(void *state, const void *input)
{
sph_blake256_context ctx_blake;
sph_bmw256_context ctx_bmw;
sph_keccak256_context ctx_keccak;
sph_skein256_context ctx_skein;
sph_cubehash256_context ctx_cube;
uint32_t hashA[8], hashB[8];
sph_blake256_init(&ctx_blake);
sph_blake256 (&ctx_blake, input, 80);
sph_blake256_close (&ctx_blake, hashA);
sph_keccak256_init(&ctx_keccak);
sph_keccak256 (&ctx_keccak,hashA, 32);
sph_keccak256_close(&ctx_keccak, hashB);
sph_cubehash256_init(&ctx_cube);
sph_cubehash256(&ctx_cube, hashB, 32);
sph_cubehash256_close(&ctx_cube, hashA);
LYRA2(hashB, 32, hashA, 32, hashA, 32, 1, 4, 4);
sph_skein256_init(&ctx_skein);
sph_skein256 (&ctx_skein, hashB, 32);
sph_skein256_close(&ctx_skein, hashA);
sph_cubehash256_init(&ctx_cube);
sph_cubehash256(&ctx_cube, hashA, 32);
sph_cubehash256_close(&ctx_cube, hashB);
sph_bmw256_init(&ctx_bmw);
sph_bmw256 (&ctx_bmw, hashB, 32);
sph_bmw256_close(&ctx_bmw, hashA);
//printf("cpu hash %08x %08x %08x %08x\n",hashA[0],hashA[1],hashA[2],hashA[3]);
memcpy(state, hashA, 32);
}
void hive_hash(const char* input, char* output)
{
sph_blake256_context ctx_blake;
sph_shabal256_context ctx_shabal;
sph_keccak256_context ctx_keccak;
// uint32_t hashA[16], hashB[16];
uint32_t hashA[8], hashB[8];
sph_shabal256_init(&ctx_shabal);
sph_shabal256 (&ctx_shabal, input, 80);
sph_shabal256_close (&ctx_shabal, hashA); //0
POMELO(hashB, 32, hashA, 32, hashA, 32, 2, 10);
sph_blake256_init(&ctx_blake);
sph_blake256 (&ctx_blake, hashA, 32); //0
sph_blake256_close(&ctx_blake, hashB); //1
sph_keccak256_init(&ctx_keccak);
sph_keccak256 (&ctx_keccak, hashB, 32); //2
sph_keccak256_close(&ctx_keccak, hashA); //3
memcpy(output, hashA, 32);
}
void lyra2re2_hash(const char* input, char* output)
{
sph_blake256_context ctx_blake;
sph_cubehash256_context ctx_cubehash;
sph_keccak256_context ctx_keccak;
sph_skein256_context ctx_skein;
sph_bmw256_context ctx_bmw;
uint32_t hashA[8], hashB[8];
sph_blake256_init(&ctx_blake);
sph_blake256(&ctx_blake, input, 80);
sph_blake256_close (&ctx_blake, hashA);
sph_keccak256_init(&ctx_keccak);
sph_keccak256(&ctx_keccak, hashA, 32);
sph_keccak256_close(&ctx_keccak, hashB);
sph_cubehash256_init(&ctx_cubehash);
sph_cubehash256(&ctx_cubehash, hashB, 32);
sph_cubehash256_close(&ctx_cubehash, hashA);
LYRA2(hashB, 32, hashA, 32, hashA, 32, 1, 4, 4);
sph_skein256_init(&ctx_skein);
sph_skein256(&ctx_skein, hashB, 32);
sph_skein256_close(&ctx_skein, hashA);
sph_cubehash256_init(&ctx_cubehash);
sph_cubehash256(&ctx_cubehash, hashA, 32);
sph_cubehash256_close(&ctx_cubehash, hashB);
sph_bmw256_init(&ctx_bmw);
sph_bmw256(&ctx_bmw, hashB, 32);
sph_bmw256_close(&ctx_bmw, hashA);
memcpy(output, hashA, 32);
}
inline void lyra2rehash(void *state, const void *input)
{
sph_blake256_context ctx_blake;
sph_groestl256_context ctx_groestl;
sph_keccak256_context ctx_keccak;
sph_skein256_context ctx_skein;
uint32_t hashA[8], hashB[8];
sph_blake256_init(&ctx_blake);
sph_blake256 (&ctx_blake, input, 80);
sph_blake256_close (&ctx_blake, hashA);
sph_keccak256_init(&ctx_keccak);
sph_keccak256 (&ctx_keccak,hashA, 32);
sph_keccak256_close(&ctx_keccak, hashB);
LYRA2(hashA, 32, hashB, 32, hashB, 32, 1, 8, 8);
sph_skein256_init(&ctx_skein);
sph_skein256 (&ctx_skein, hashA, 32);
sph_skein256_close(&ctx_skein, hashB);
sph_groestl256_init(&ctx_groestl);
sph_groestl256 (&ctx_groestl, hashB, 32);
sph_groestl256_close(&ctx_groestl, hashA);
//printf("cpu hash %08x %08x %08x %08x\n",hashA[0],hashA[1],hashA[2],hashA[3]);
memcpy(state, hashA, 32);
}
int main()
{
char t[]="AAAA";
unsigned char out[32];
//crypto_hash(out, t, 4);
sph_keccak256_context ctx_keccak;
sph_keccak256_init(&ctx_keccak);
sph_keccak256 (&ctx_keccak, t, 4);
sph_keccak256_close(&ctx_keccak, (void*)out);
int i=0;
for(;i<32;i++)
printf("%02x",out[i]);
printf("\n");
return 0;
}
