Пример #1
0
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 );
}
Пример #2
0
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);
}
Пример #3
0
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);

}
Пример #4
0
void phi1612_hash(void *state, const void *input)
{
	sph_skein512_context        ctx_skein;
	sph_jh512_context           ctx_jh;
	sph_cubehash512_context     ctx_cubehash;
	sph_fugue512_context        ctx_fugue;
	sph_gost512_context         ctx_gost;
	sph_echo512_context         ctx_echo;

	uint8_t _ALIGN(128) hash[64];

	sph_skein512_init(&ctx_skein);
	sph_skein512(&ctx_skein, input, 80);
	sph_skein512_close(&ctx_skein, (void*) hash);

	sph_jh512_init(&ctx_jh);
	sph_jh512(&ctx_jh, (const void*) hash, 64);
	sph_jh512_close(&ctx_jh, (void*) hash);

	sph_cubehash512_init(&ctx_cubehash);
	sph_cubehash512(&ctx_cubehash, (const void*) hash, 64);
	sph_cubehash512_close(&ctx_cubehash, (void*) hash);

	sph_fugue512_init(&ctx_fugue);
	sph_fugue512(&ctx_fugue, (const void*) hash, 64);
	sph_fugue512_close(&ctx_fugue, (void*) hash);

	sph_gost512_init(&ctx_gost);
	sph_gost512(&ctx_gost, (const void*) hash, 64);
	sph_gost512_close(&ctx_gost, (void*) hash);

	sph_echo512_init(&ctx_echo);
	sph_echo512(&ctx_echo, (const void*) hash, 64);
	sph_echo512_close(&ctx_echo, (void*) hash);

	memcpy(state, hash, 32);
}