//-----------------------------------------------------------------
crypto::secret_key account_base::generate(const crypto::secret_key& recovery_key, bool recover, bool two_random)
{
crypto::secret_key first = generate_keys(m_keys.m_account_address.m_spend_public_key, m_keys.m_spend_secret_key, recovery_key, recover);
// rng for generating second set of keys is hash of first rng. means only one set of electrum-style words needed for recovery
crypto::secret_key second;
keccak((uint8_t *)&first, sizeof(crypto::secret_key), (uint8_t *)&second, sizeof(crypto::secret_key));
generate_keys(m_keys.m_account_address.m_view_public_key, m_keys.m_view_secret_key, second, two_random ? false : true);
struct tm timestamp;
timestamp.tm_year = 2014 - 1900; // year 2014
timestamp.tm_mon = 6 - 1; // month june
timestamp.tm_mday = 8; // 8th of june
timestamp.tm_hour = 0;
timestamp.tm_min = 0;
timestamp.tm_sec = 0;
if (recover)
{
m_creation_timestamp = mktime(×tamp);
}
else
{
m_creation_timestamp = time(NULL);
}
return first;
}
void hmac_keccak_init(hmac_keccak_state *S, const uint8_t *_key, size_t keylen) {
const uint8_t *key = _key;
uint8_t keyhash[HASH_SIZE];
uint8_t pad[KECCAK_BLOCKLEN];
uint64_t i;
if (keylen > KECCAK_BLOCKLEN) {
keccak(key, keylen, keyhash, HASH_SIZE);
key = keyhash;
keylen = HASH_SIZE;
}
keccak_init(&S->inner);
memset(pad, 0x36, KECCAK_BLOCKLEN);
for (i = 0; i < keylen; ++i) {
pad[i] ^= key[i];
}
keccak_update(&S->inner, pad, KECCAK_BLOCKLEN);
keccak_init(&S->outer);
memset(pad, 0x5c, KECCAK_BLOCKLEN);
for (i = 0; i < keylen; ++i) {
pad[i] ^= key[i];
}
keccak_update(&S->outer, pad, KECCAK_BLOCKLEN);
memwipe(keyhash, HASH_SIZE);
}
//-----------------------------------------------------------------
crypto::secret_key account_base::generate(const crypto::secret_key& recovery_key, bool recover, bool two_random)
{
crypto::secret_key first = generate_keys(m_keys.m_account_address.m_spend_public_key, m_keys.m_spend_secret_key, recovery_key, recover);
// rng for generating second set of keys is hash of first rng. means only one set of electrum-style words needed for recovery
crypto::secret_key second;
keccak((uint8_t *)&first, sizeof(crypto::secret_key), (uint8_t *)&second, sizeof(crypto::secret_key));
generate_keys(m_keys.m_account_address.m_view_public_key, m_keys.m_view_secret_key, second, two_random ? false : true);
m_creation_timestamp = time(NULL);
return first;
}
int keccak_test()
{
test_triplet_t testvec[4] = {
{
28, "Keccak-224 Test Hash", {
0x30, 0x04, 0x5B, 0x34, 0x94, 0x6E, 0x1B, 0x2E,
0x09, 0x16, 0x13, 0x36, 0x2F, 0xD2, 0x2A, 0xA0,
0x8E, 0x2B, 0xEA, 0xFE, 0xC5, 0xE8, 0xDA, 0xEE,
0x42, 0xC2, 0xE6, 0x65 }
}, {
32, "Keccak-256 Test Hash", {
0xA8, 0xD7, 0x1B, 0x07, 0xF4, 0xAF, 0x26, 0xA4,
0xFF, 0x21, 0x02, 0x7F, 0x62, 0xFF, 0x60, 0x26,
0x7F, 0xF9, 0x55, 0xC9, 0x63, 0xF0, 0x42, 0xC4,
0x6D, 0xA5, 0x2E, 0xE3, 0xCF, 0xAF, 0x3D, 0x3C }
}, {
48, "Keccak-384 Test Hash", {
0xE2, 0x13, 0xFD, 0x74, 0xAF, 0x0C, 0x5F, 0xF9,
0x1B, 0x42, 0x3C, 0x8B, 0xCE, 0xEC, 0xD7, 0x01,
0xF8, 0xDD, 0x64, 0xEC, 0x18, 0xFD, 0x6F, 0x92,
0x60, 0xFC, 0x9E, 0xC1, 0xED, 0xBD, 0x22, 0x30,
0xA6, 0x90, 0x86, 0x65, 0xBC, 0xD9, 0xFB, 0xF4,
0x1A, 0x99, 0xA1, 0x8A, 0x7D, 0x9E, 0x44, 0x6E }
}, {
64, "Keccak-512 Test Hash", {
0x96, 0xEE, 0x47, 0x18, 0xDC, 0xBA, 0x3C, 0x74,
0x61, 0x9B, 0xA1, 0xFA, 0x7F, 0x57, 0xDF, 0xE7,
0x76, 0x9D, 0x3F, 0x66, 0x98, 0xA8, 0xB3, 0x3F,
0xA1, 0x01, 0x83, 0x89, 0x70, 0xA1, 0x31, 0xE6,
0x21, 0xCC, 0xFD, 0x05, 0xFE, 0xFF, 0xBC, 0x11,
0x80, 0xF2, 0x63, 0xC2, 0x7F, 0x1A, 0xDA, 0xB4,
0x60, 0x95, 0xD6, 0xF1, 0x25, 0x33, 0x14, 0x72,
0x4B, 0x5C, 0xBF, 0x78, 0x28, 0x65, 0x8E, 0x6A }
}
};
int i, fails;
uint8_t md[64];
fails = 0;
for (i = 0; i < 4; i++) {
keccak((uint8_t *) testvec[i].msgstr,
strlen(testvec[i].msgstr),
md, testvec[i].mdlen);
if (memcmp(md, testvec[i].md, testvec[i].mdlen)) {
fails++;
fprintf(stderr, "Keccak-%d FAILED.", testvec[i].mdlen * 8);
}
}
return fails;
}
int main()
{
#if 0
uint8_t test_vector[] = "";
uint8_t output[64];
memset(output, 0, sizeof(output));
// sha3 512
keccak(576, 1024, 0x06, test_vector, sizeof(test_vector) * sizeof(uint8_t) - 1, output, sizeof(output) * sizeof(uint8_t));
size_t i;
for (i = 0; i < (sizeof(output) * sizeof(uint8_t)); i++)
printf("%02x", output[i]);
printf("\n");
#endif
return 0;
}
int main(int argc, char **argv)
{
int inlen,i,j;
ALIGN char *msgstr[4];
ALIGN uint8_t *md[4];
ALIGN uint8_t *md1[64];
if(argc != 2){
printf("ERROR!, You need to pass the message size\n\n");
exit(1);
}
inlen = atoi(argv[1]);
for(i=0;i<4;i++){
msgstr[i] = (char*)_mm_malloc(inlen*sizeof(char),32);
md[i] = (uint8_t*)_mm_malloc(64*sizeof(uint8_t),32);
md1[i] = (uint8_t*)_mm_malloc(64*sizeof(uint8_t),32);
}
for(j=0;j<4;j++){
for(i=0;i<inlen;i++){
msgstr[j][i] = (char)(rand()%256);
}
}
printf("\n 4-way implementation using 256-bit registers.\n\n");
printf("<------------------------------------------------------>\n");
printf("Keccak_256 4 way \t\t\t");
keccak(msgstr, inlen,md,136);
keccak_std(msgstr[0], inlen,md1[0],32);
keccak_std(msgstr[1], inlen,md1[1],32);
keccak_std(msgstr[2], inlen,md1[2],32);
keccak_std(msgstr[3], inlen,md1[3],32);
if((memcmp(md[0],md1[0],32) && memcmp(md[1],md1[1],32) && memcmp(md[2],md1[2],32) && memcmp(md[3],md1[3],32)) != 0){
printf("Error!!\n");
exit(1);
}
printf("Ok!!\n");
printf("Keccak_384 4 way \t\t\t");
keccak(msgstr, inlen,md,104);
keccak_std(msgstr[0], inlen,md1[0],48);
keccak_std(msgstr[1], inlen,md1[1],48);
keccak_std(msgstr[2], inlen,md1[2],48);
keccak_std(msgstr[3], inlen,md1[3],48);
if((memcmp(md[0],md1[0],48) && memcmp(md[1],md1[1],48) && memcmp(md[2],md1[2],48) && memcmp(md[3],md1[3],48)) != 0){
printf("Error!!\n");
exit(1);
}
printf("Ok!!\n");
printf("Keccak_512 4 way \t\t\t");
keccak(msgstr, inlen,md,72);
keccak_std(msgstr[0], inlen,md1[0],64);
keccak_std(msgstr[1], inlen,md1[1],64);
keccak_std(msgstr[2], inlen,md1[2],64);
keccak_std(msgstr[3], inlen,md1[3],64);
if((memcmp(md[0],md1[0],64) && memcmp(md[1],md1[1],64) && memcmp(md[2],md1[2],64) && memcmp(md[3],md1[3],64)) != 0){
printf("Error!!\n");
exit(1);
}
printf("Ok!!\n");
printf("<------------------------------------------------------>\n");
for(i=0;i<4;i++){
_mm_free(msgstr[i]);
_mm_free(md[i]);
_mm_free(md1[i]);
}
return 0;
}
void keccak1600(const uint8_t *in, int inlen, uint8_t *md)
{
keccak(in, inlen, md, sizeof(state_t));
}
//cn_fast_hash for a 128 byte unsigned char
key cn_fast_hash128(const void * in) {
key hash;
keccak((uint8_t *)in, 128, hash.bytes, 32);
return hash;
}
//cn_fast_hash for a 32 byte key
key cn_fast_hash(const key & in) {
key hash;
keccak((uint8_t *)in.bytes, 32, hash.bytes, 32);
return hash;
}
//cn_fast_hash for a 32 byte key
void cn_fast_hash(key & hash, const key & in) {
keccak((uint8_t *)in.bytes, 32, hash.bytes, 32);
}
//Hashing - cn_fast_hash
//be careful these are also in crypto namespace
//cn_fast_hash for arbitrary multiples of 32 bytes
void cn_fast_hash(key &hash, const void * data, const std::size_t l) {
keccak((uint8_t *)data, l, hash.bytes, 32);
}
/**
* Performs keecak hash on the private key provided
*/
void
keccak_hash(secret_key& prv, crypto::hash& result)
{
keccak(reinterpret_cast<uint8_t *>(&prv), sizeof(secret_key),
(uint8_t *) &result, sizeof(secret_key));
}
