240 lines
7.4 KiB
C++
240 lines
7.4 KiB
C++
// Copyright (c) 2012-2013 The Boolberry developers
|
|
// Copyright (c) 2012-2013 The Zano developers
|
|
// Distributed under the MIT/X11 software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#pragma once
|
|
//
|
|
// #include "crypto/crypto.h"
|
|
// #include "currency_core/currency_basic.h"
|
|
// #include "profile_tools.h"
|
|
//
|
|
// extern "C" {
|
|
// #include "crypto/keccak.h"
|
|
// //#include "crypto/alt/KeccakNISTInterface.h"
|
|
// }
|
|
//
|
|
//
|
|
// #include "crypto/wild_keccak.h"
|
|
// //#include "crypto/wild_keccak2.h"
|
|
// #include "../core_tests/random_helper.h"
|
|
// #include "crypto/hash.h"
|
|
//
|
|
//
|
|
//
|
|
//
|
|
// #define TEST_BUFF_LEN 200
|
|
//
|
|
// class test_keccak_base
|
|
// {
|
|
// public:
|
|
// static const size_t loop_count = 100000;
|
|
//
|
|
// bool init()
|
|
// {
|
|
// currency::block b;
|
|
// m_buff = currency::get_block_hashing_blob(b);
|
|
// m_buff.append(32 * 4, 0);
|
|
// return true;
|
|
// }
|
|
//
|
|
// bool pretest()
|
|
// {
|
|
// ++m_buff[0];
|
|
// if (!m_buff[0])
|
|
// ++m_buff[0];
|
|
// return true;
|
|
// }
|
|
// protected:
|
|
// std::string m_buff;
|
|
// };
|
|
//
|
|
// // class test_keccak : public test_keccak_base
|
|
// // {
|
|
// // public:
|
|
// // bool test()
|
|
// // {
|
|
// // pretest();
|
|
// // crypto::hash h;
|
|
// // keccak(reinterpret_cast<const uint8_t*>(&m_buff[0]), m_buff.size(), reinterpret_cast<uint8_t*>(&h), sizeof(h));
|
|
// // LOG_PRINT_L4(h);
|
|
// // return true;
|
|
// // }
|
|
// // };
|
|
//
|
|
//
|
|
// class test_keccak_generic : public test_keccak_base
|
|
// {
|
|
// public:
|
|
// bool test()
|
|
// {
|
|
// pretest();
|
|
// crypto::hash h;
|
|
// crypto::keccak_generic<crypto::regular_f>(reinterpret_cast<const uint8_t*>(&m_buff[0]), m_buff.size(), reinterpret_cast<uint8_t*>(&h), sizeof(h));
|
|
// LOG_PRINT_L4(h);
|
|
// return true;
|
|
// }
|
|
// };
|
|
//
|
|
// class test_keccak_generic_with_mul : public test_keccak_base
|
|
// {
|
|
// public:
|
|
// bool test()
|
|
// {
|
|
// pretest();
|
|
// crypto::hash h;
|
|
// crypto::keccak_generic<crypto::mul_f>(reinterpret_cast<const uint8_t*>(&m_buff[0]), m_buff.size(), reinterpret_cast<uint8_t*>(&h), sizeof(h));
|
|
// return true;
|
|
// }
|
|
// };
|
|
//
|
|
// template<int scratchpad_size>
|
|
// class test_wild_keccak : public test_keccak_base
|
|
// {
|
|
// public:
|
|
// bool init()
|
|
// {
|
|
// m_scratchpad_vec.resize(scratchpad_size / sizeof(crypto::hash));
|
|
// for (auto& h : m_scratchpad_vec)
|
|
// h = crypto::rand<crypto::hash>();
|
|
//
|
|
// return test_keccak_base::init();
|
|
// }
|
|
//
|
|
// bool test()
|
|
// {
|
|
// pretest();
|
|
//
|
|
// crypto::hash h;
|
|
// crypto::wild_keccak_dbl<crypto::mul_f>(reinterpret_cast<const uint8_t*>(&m_buff[0]), m_buff.size(), reinterpret_cast<uint8_t*>(&h), sizeof(h), [&](crypto::state_t_m& st, crypto::mixin_t& mix)
|
|
// {
|
|
// #define SCR_I(i) m_scratchpad_vec[st[i]%m_scratchpad_vec.size()]
|
|
// for (size_t i = 0; i != 6; i++)
|
|
// {
|
|
// OPT_XOR_4_RES(SCR_I(i * 4), SCR_I(i * 4 + 1), SCR_I(i * 4 + 2), SCR_I(i * 4 + 3), *(crypto::hash*)&mix[i * 4]);
|
|
// }
|
|
// });
|
|
//
|
|
// return true;
|
|
// }
|
|
// protected:
|
|
// std::vector<crypto::hash> m_scratchpad_vec;
|
|
// };
|
|
//
|
|
// //
|
|
// // template<int scratchpad_size>
|
|
// // class test_wild_keccak2 : public test_keccak_base
|
|
// // {
|
|
// // public:
|
|
// // bool init()
|
|
// // {
|
|
// // m_scratchpad_vec.resize(scratchpad_size / sizeof(crypto::hash));
|
|
// // for (auto& h : m_scratchpad_vec)
|
|
// // h = crypto::rand<crypto::hash>();
|
|
// //
|
|
// // return test_keccak_base::init();
|
|
// // }
|
|
// //
|
|
// // bool test()
|
|
// // {
|
|
// // pretest();
|
|
// //
|
|
// // crypto::hash h2;
|
|
// // crypto::wild_keccak_dbl_opt(reinterpret_cast<const uint8_t*>(&m_buff[0]), m_buff.size(), reinterpret_cast<uint8_t*>(&h2), sizeof(h2), (const UINT64*)&m_scratchpad_vec[0], m_scratchpad_vec.size() * 4);
|
|
// // LOG_PRINT_L4("HASH:" << h2);
|
|
// // return true;
|
|
// // }
|
|
// // protected:
|
|
// // std::vector<crypto::hash> m_scratchpad_vec;
|
|
// // };
|
|
//
|
|
// #ifdef _DEBUG
|
|
// #define max_measere_scratchpad 100000
|
|
// #else
|
|
// #define max_measere_scratchpad 50000000
|
|
// #endif
|
|
// #define measere_rounds 10000
|
|
//
|
|
// void generate_scratchpad()
|
|
// {
|
|
// crypto::hash seed = crypto::cn_fast_hash("sdssdsffdss", 10);
|
|
// std::vector<crypto::hash> scratchpad;
|
|
// size_t count = 500000000 / 32;
|
|
// TIME_MEASURE_START_MS(gen_time);
|
|
// LOG_PRINT_L0("Generating....");
|
|
// crypto::generate_scratchpad2(seed, scratchpad, count);
|
|
// TIME_MEASURE_FINISH_MS(gen_time);
|
|
// LOG_PRINT_L0("Generated scratchpad " << (scratchpad.size() * 32) / (1024 * 1024) << "MB in " << gen_time << "ms");
|
|
// }
|
|
//
|
|
// void generate_light_scratchpad()
|
|
// {
|
|
// crypto::hash seed = crypto::cn_fast_hash("sdssdsffdss", 10);
|
|
// std::vector<crypto::hash> scratchpad;
|
|
// size_t count = 500000000 / 32;
|
|
// TIME_MEASURE_START_MS(gen_time);
|
|
// LOG_PRINT_L0("Generating....");
|
|
// crypto::generate_scratchpad_light(seed, scratchpad, count);
|
|
// TIME_MEASURE_FINISH_MS(gen_time);
|
|
// LOG_PRINT_L0("Generated scratchpad " << (scratchpad.size() * 32) / (1024 * 1024) << "MB in " << gen_time << "ms");
|
|
// }
|
|
//
|
|
//
|
|
// void measure_keccak_over_scratchpad(uint64_t start_scratchpad_size, uint64_t step_size)
|
|
// {
|
|
// // std::cout << std::setw(20) << std::left << "sz\t" <<
|
|
// //std::setw(10) << "original\t" <<
|
|
// // std::setw(10) << "original opt\t" <<
|
|
// // std::setw(10) << "w2\t" <<
|
|
// // std::setw(10) << "w2_opt" << ENDL;
|
|
//
|
|
// std::vector<crypto::hash> scratchpad_vec;
|
|
// scratchpad_vec.resize(max_measere_scratchpad);
|
|
// std::string has_str = "Keccak is a family of sponge functions. The sponge function is a generalization of the concept of cryptographic hash function with infinite output and can perform quasi all symmetric cryptographic functions, from hashing to pseudo-random number generation to authenticated encryption";
|
|
//
|
|
// for (size_t j = 0; j != scratchpad_vec.size(); j++)
|
|
// scratchpad_vec[j] = crypto::rand<crypto::hash>();
|
|
//
|
|
// for (uint64_t i = start_scratchpad_size; i < max_measere_scratchpad; i += i/10)
|
|
// {
|
|
//
|
|
// crypto::hash res_h = currency::null_hash;
|
|
// uint64_t ticks_a = epee::misc_utils::get_tick_count();
|
|
// *(uint64_t*)(&has_str[8]) = i;
|
|
//
|
|
// uint64_t ticks_b = epee::misc_utils::get_tick_count();
|
|
// for (size_t r = 0; r != measere_rounds; r++)
|
|
// {
|
|
// *(size_t*)(&has_str[1]) = r;
|
|
// crypto::get_wild_keccak(has_str, res_h, 1, scratchpad_vec, i);
|
|
// }
|
|
//
|
|
// //wild keccak 2
|
|
// uint64_t ticks_c = epee::misc_utils::get_tick_count();
|
|
// for (size_t r = 0; r != measere_rounds; r++)
|
|
// {
|
|
// *(size_t*)(&has_str[1]) = r;
|
|
// res_h = crypto::cn_fast_hash(has_str.data(), has_str.size());
|
|
// }
|
|
// //wild keccak 2 opt
|
|
// uint64_t ticks_d = epee::misc_utils::get_tick_count();
|
|
// for (size_t r = 0; r != measere_rounds; r++)
|
|
// {
|
|
// crypto::get_wild_keccak2(has_str, res_h, scratchpad_vec, i);
|
|
// }
|
|
//
|
|
// uint64_t ticks_e = epee::misc_utils::get_tick_count();
|
|
// std::cout << std::setw(20) << std::left << i * sizeof(crypto::hash) << "\t" <<
|
|
// //std::setw(10) << ticks_b - ticks_a << "\t" <<
|
|
// //std::setw(10) << ticks_c - ticks_b << "\t" <<
|
|
// std::setw(10) << ticks_d - ticks_c << "\t" <<
|
|
// std::setw(10) << ticks_e - ticks_d << ENDL;
|
|
// }
|
|
// }
|
|
//
|
|
// void measure_keccak_over_scratchpad()
|
|
// {
|
|
// //measure_keccak_over_scratchpad(100/32, 100/32);
|
|
// //measure_keccak_over_scratchpad(10, max_measere_scratchpad / 10);
|
|
// measure_keccak_over_scratchpad(max_measere_scratchpad/10, 0);
|
|
// }
|