void go(uint32_t size, uint32_t iter)
{
uint32_t seed = current_time();
srand(seed);
uint8_t *byte_array = generate_random_bytes(size);
// uint32_t rand_index = random_int(0, size);
// printf("SIZE: %u ITERS: %u ASM: %u\n", size, iter, useASM);
// uint64_t start = current_time();
// uint8_t b = byte_array[rand_index];
for(uint32_t i = 0; i < iter; i ++){
// Start time
// uint32_t rand_index = random_int(0, size);
uint64_t start = current_time();
// printf("byte at %u %hhu\n", i, byte_array[i]);
// uint8_t b = byte_array[rand_index];
uint8_t b = byte_array[i];
uint64_t end = current_time();
printf("%u, %hhu, %llu\n", i, b, end - start);
// Print
}
// mean_time = (end-start)/size;
// printf("%u %hhu %llu ns\n", rand_index, b, end - start);
free(byte_array);
}
Domain::DataKey DEKPool::generate_new_data_key() {
Domain::DataKey data_key;
std::string encoded_dek;
std::string master_key = CardCrypter::assemble_master_key(config_, session_);
AESCrypter aes_crypter(master_key);
while (true) {
std::string dek_value = generate_random_bytes(32);
try {
encoded_dek = encode_base64(aes_crypter.encrypt(dek_value));
auto count = Yb::query<Domain::DataKey>(session_)
.filter_by(Domain::DataKey::c.dek_crypted == encoded_dek)
.count();
if (!count)
break;
} catch(AESBlockSizeException &exc) {
std::cout << exc.what() << std::endl;
}
}
data_key.dek_crypted = encoded_dek;
data_key.start_ts = Yb::now();
data_key.finish_ts = Yb::dt_make(2020, 12, 31);
data_key.counter = 0;
data_key.save(session_);
session_.flush();
return data_key;
}
int main(int argc, char* argv[]) {
if (argc < 2) {
printf("Usage: %s METHOD\n", argv[0]);
return -1;
}
printf("Hash size is: %d\n", HASH_BYTES);
struct timespec start_time, end_time;
timespec_get(&start_time, TIME_UTC);
srand((unsigned int)time(NULL));
hash_t m1;
hash_t m2;
if (strcmp(argv[1], "b") == 0) {
// generate random y0
uint8_t y0[HASH_BYTES];
generate_random_bytes(HASH_BYTES, y0);
hash_str_t y0_str;
sprint_hash_hex(y0, y0_str);
printf("Random y0: %s\n", y0_str);
printf("Starting cycle finding...\n");
uint64_t lambda, mu;
brents_cycle_find_collision(HASH_BYTES, y0, hash_function,
&lambda, &mu, m1, m2, brents_power_updated);
printf("lambda: %" PRIu64 "\n", lambda);
printf("mu: %" PRIu64 "\n", mu);
} else if (strcmp(argv[1], "dp") == 0) {
if (argc < 4) {
printf("Usage: %s dp NUM_THREADS NUM_LEADING_ZEROS\n", argv[0]);
return -1;
}
unsigned int num_threads = strtol(argv[2], NULL, 10);
if (num_threads == 0) {
printf("Usage: %s NUM_THREADS NUM_LEADING_ZEROS\n", argv[0]);
return -1;
}
unsigned int num_leading_zeros = strtol(argv[3], NULL, 10);
printf("Using %u leading zeros as dp-property!\n", num_leading_zeros);
dp_find_collision_parallel(HASH_BYTES, hash_function,
generate_random_bytes, num_threads, num_leading_zeros, m1,
m2, dp_found_dp);
} else if (strcmp(argv[1], "test") == 0) {
// test iteration speed
if (argc < 3) {
printf("Expecting iteration parameter!\n");
return -1;
}
unsigned long num_iterations = strtoul(argv[2], NULL, 10);
if (num_iterations == 0) {
printf("Invalid number of iterations: %s\n", argv[2]);
return -1;
}
printf("Running %lu hash iterations...\n", num_iterations);
uint8_t y0[HASH_BYTES];
generate_random_bytes(HASH_BYTES, y0);
for (unsigned long i = 0; i < num_iterations; ++i) {
hash_function(y0, HASH_BYTES, y0);
}
} else {
printf("Unknown method!\n");
return -1;
}
hash_t h1, h2;
truncated_md5(m1, HASH_BYTES, h1);
truncated_md5(m2, HASH_BYTES, h2);
hash_str_t m1_str, m2_str, h1_str, h2_str;
sprint_hash_hex(m1, m1_str);
sprint_hash_hex(m2, m2_str);
sprint_hash_hex(h1, h1_str);
sprint_hash_hex(h2, h2_str);
printf("m1: %s -> %s\n", m1_str, h1_str);
printf("m2: %s -> %s\n", m2_str, h2_str);
printf("Hamming distance: %u\n",
hamming_distance_bytes(h1, h2, HASH_BYTES));
timespec_get(&end_time, TIME_UTC);
printf("Computation took %ld seconds...\n",
end_time.tv_sec - start_time.tv_sec);
return 0;
}
