mirror of
https://git.sr.ht/~sircmpwn/mkproof
synced 2024-05-03 22:26:33 +02:00
112 lines
3.3 KiB
C
112 lines
3.3 KiB
C
/*
|
|
* Argon2 reference source code package - reference C implementations
|
|
*
|
|
* Copyright 2015
|
|
* Daniel Dinu, Dmitry Khovratovich, Jean-Philippe Aumasson, and Samuel Neves
|
|
*
|
|
* You may use this work under the terms of a Creative Commons CC0 1.0
|
|
* License/Waiver or the Apache Public License 2.0, at your option. The terms of
|
|
* these licenses can be found at:
|
|
*
|
|
* - CC0 1.0 Universal : https://creativecommons.org/publicdomain/zero/1.0
|
|
* - Apache 2.0 : https://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* You should have received a copy of both of these licenses along with this
|
|
* software. If not, they may be obtained at the above URLs.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
#ifdef _WIN32
|
|
#include <intrin.h>
|
|
#endif
|
|
|
|
#include "argon2.h"
|
|
|
|
static uint64_t rdtsc(void) {
|
|
#ifdef _WIN32
|
|
return __rdtsc();
|
|
#else
|
|
#if defined(__amd64__) || defined(__x86_64__)
|
|
uint64_t rax, rdx;
|
|
__asm__ __volatile__("rdtsc" : "=a"(rax), "=d"(rdx) : :);
|
|
return (rdx << 32) | rax;
|
|
#elif defined(__i386__) || defined(__i386) || defined(__X86__)
|
|
uint64_t rax;
|
|
__asm__ __volatile__("rdtsc" : "=A"(rax) : :);
|
|
return rax;
|
|
#else
|
|
#error "Not implemented!"
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* Benchmarks Argon2 with salt length 16, password length 16, t_cost 3,
|
|
and different m_cost and threads
|
|
*/
|
|
static void benchmark() {
|
|
#define BENCH_OUTLEN 16
|
|
#define BENCH_INLEN 16
|
|
const uint32_t inlen = BENCH_INLEN;
|
|
const unsigned outlen = BENCH_OUTLEN;
|
|
unsigned char out[BENCH_OUTLEN];
|
|
unsigned char pwd_array[BENCH_INLEN];
|
|
unsigned char salt_array[BENCH_INLEN];
|
|
#undef BENCH_INLEN
|
|
#undef BENCH_OUTLEN
|
|
|
|
uint32_t t_cost = 3;
|
|
uint32_t m_cost;
|
|
uint32_t thread_test[4] = {1, 2, 4, 8};
|
|
argon2_type types[3] = {Argon2_i, Argon2_d, Argon2_id};
|
|
|
|
memset(pwd_array, 0, inlen);
|
|
memset(salt_array, 1, inlen);
|
|
|
|
for (m_cost = (uint32_t)1 << 10; m_cost <= (uint32_t)1 << 22; m_cost *= 2) {
|
|
unsigned i;
|
|
for (i = 0; i < 4; ++i) {
|
|
double run_time = 0;
|
|
uint32_t thread_n = thread_test[i];
|
|
|
|
unsigned j;
|
|
for (j = 0; j < 3; ++j) {
|
|
clock_t start_time, stop_time;
|
|
uint64_t start_cycles, stop_cycles;
|
|
uint64_t delta;
|
|
double mcycles;
|
|
|
|
argon2_type type = types[j];
|
|
start_time = clock();
|
|
start_cycles = rdtsc();
|
|
|
|
argon2_hash(t_cost, m_cost, thread_n, pwd_array, inlen,
|
|
salt_array, inlen, out, outlen, NULL, 0, type,
|
|
ARGON2_VERSION_NUMBER);
|
|
|
|
stop_cycles = rdtsc();
|
|
stop_time = clock();
|
|
|
|
delta = (stop_cycles - start_cycles) / (m_cost);
|
|
mcycles = (double)(stop_cycles - start_cycles) / (1UL << 20);
|
|
run_time += ((double)stop_time - start_time) / (CLOCKS_PER_SEC);
|
|
|
|
printf("%s %d iterations %d MiB %d threads: %2.2f cpb %2.2f "
|
|
"Mcycles \n", argon2_type2string(type, 1), t_cost,
|
|
m_cost >> 10, thread_n, (float)delta / 1024, mcycles);
|
|
}
|
|
|
|
printf("%2.4f seconds\n\n", run_time);
|
|
}
|
|
}
|
|
}
|
|
|
|
int main() {
|
|
benchmark();
|
|
return ARGON2_OK;
|
|
}
|