|
|
|
|
@ -10,7 +10,7 @@
|
|
|
|
|
#include "nist256p1.h"
|
|
|
|
|
#include "ed25519.h"
|
|
|
|
|
|
|
|
|
|
static uint8_t msg[32];
|
|
|
|
|
static uint8_t msg[256];
|
|
|
|
|
|
|
|
|
|
void prepare_msg(void)
|
|
|
|
|
{
|
|
|
|
|
@ -19,7 +19,47 @@ void prepare_msg(void)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void bench_secp256k1(void)
|
|
|
|
|
void bench_sign_secp256k1(int iterations)
|
|
|
|
|
{
|
|
|
|
|
uint8_t sig[64], priv[32], pby;
|
|
|
|
|
|
|
|
|
|
const ecdsa_curve *curve = &secp256k1;
|
|
|
|
|
|
|
|
|
|
memcpy(priv, "\xc5\x5e\xce\x85\x8b\x0d\xdd\x52\x63\xf9\x68\x10\xfe\x14\x43\x7c\xd3\xb5\xe1\xfb\xd7\xc6\xa2\xec\x1e\x03\x1f\x05\xe8\x6d\x8b\xd5", 32);
|
|
|
|
|
|
|
|
|
|
for (int i = 0 ; i < iterations; i++) {
|
|
|
|
|
ecdsa_sign(curve, priv, msg, sizeof(msg), sig, &pby, NULL);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void bench_sign_nist256p1(int iterations)
|
|
|
|
|
{
|
|
|
|
|
uint8_t sig[64], priv[32], pby;
|
|
|
|
|
|
|
|
|
|
const ecdsa_curve *curve = &nist256p1;
|
|
|
|
|
|
|
|
|
|
memcpy(priv, "\xc5\x5e\xce\x85\x8b\x0d\xdd\x52\x63\xf9\x68\x10\xfe\x14\x43\x7c\xd3\xb5\xe1\xfb\xd7\xc6\xa2\xec\x1e\x03\x1f\x05\xe8\x6d\x8b\xd5", 32);
|
|
|
|
|
|
|
|
|
|
for (int i = 0 ; i < iterations; i++) {
|
|
|
|
|
ecdsa_sign(curve, priv, msg, sizeof(msg), sig, &pby, NULL);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void bench_sign_ed25519(int iterations)
|
|
|
|
|
{
|
|
|
|
|
ed25519_public_key pk;
|
|
|
|
|
ed25519_secret_key sk;
|
|
|
|
|
ed25519_signature sig;
|
|
|
|
|
|
|
|
|
|
memcpy(pk, "\xc5\x5e\xce\x85\x8b\x0d\xdd\x52\x63\xf9\x68\x10\xfe\x14\x43\x7c\xd3\xb5\xe1\xfb\xd7\xc6\xa2\xec\x1e\x03\x1f\x05\xe8\x6d\x8b\xd5", 32);
|
|
|
|
|
ed25519_publickey(sk, pk);
|
|
|
|
|
|
|
|
|
|
for (int i = 0 ; i < iterations; i++) {
|
|
|
|
|
ed25519_sign(msg, sizeof(msg), sk, pk, sig);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void bench_verify_secp256k1_33(int iterations)
|
|
|
|
|
{
|
|
|
|
|
uint8_t sig[64], pub[33], priv[32], pby;
|
|
|
|
|
|
|
|
|
|
@ -29,15 +69,27 @@ void bench_secp256k1(void)
|
|
|
|
|
ecdsa_get_public_key33(curve, priv, pub);
|
|
|
|
|
ecdsa_sign(curve, priv, msg, sizeof(msg), sig, &pby, NULL);
|
|
|
|
|
|
|
|
|
|
clock_t t = clock();
|
|
|
|
|
for (int i = 0 ; i < 500; i++) {
|
|
|
|
|
int res = ecdsa_verify(curve, pub, sig, msg, sizeof(msg));
|
|
|
|
|
assert(res == 0);
|
|
|
|
|
for (int i = 0 ; i < iterations; i++) {
|
|
|
|
|
ecdsa_verify(curve, pub, sig, msg, sizeof(msg));
|
|
|
|
|
}
|
|
|
|
|
printf("SECP256k1 verifying speed: %0.2f sig/s\n", 500.0f / ((float)(clock() - t) / CLOCKS_PER_SEC));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void bench_nist256p1(void)
|
|
|
|
|
void bench_verify_secp256k1_65(int iterations)
|
|
|
|
|
{
|
|
|
|
|
uint8_t sig[64], pub[65], priv[32], pby;
|
|
|
|
|
|
|
|
|
|
const ecdsa_curve *curve = &secp256k1;
|
|
|
|
|
|
|
|
|
|
memcpy(priv, "\xc5\x5e\xce\x85\x8b\x0d\xdd\x52\x63\xf9\x68\x10\xfe\x14\x43\x7c\xd3\xb5\xe1\xfb\xd7\xc6\xa2\xec\x1e\x03\x1f\x05\xe8\x6d\x8b\xd5", 32);
|
|
|
|
|
ecdsa_get_public_key65(curve, priv, pub);
|
|
|
|
|
ecdsa_sign(curve, priv, msg, sizeof(msg), sig, &pby, NULL);
|
|
|
|
|
|
|
|
|
|
for (int i = 0 ; i < iterations; i++) {
|
|
|
|
|
ecdsa_verify(curve, pub, sig, msg, sizeof(msg));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void bench_verify_nist256p1_33(int iterations)
|
|
|
|
|
{
|
|
|
|
|
uint8_t sig[64], pub[33], priv[32], pby;
|
|
|
|
|
|
|
|
|
|
@ -47,15 +99,27 @@ void bench_nist256p1(void)
|
|
|
|
|
ecdsa_get_public_key33(curve, priv, pub);
|
|
|
|
|
ecdsa_sign(curve, priv, msg, sizeof(msg), sig, &pby, NULL);
|
|
|
|
|
|
|
|
|
|
clock_t t = clock();
|
|
|
|
|
for (int i = 0 ; i < 500; i++) {
|
|
|
|
|
int res = ecdsa_verify(curve, pub, sig, msg, sizeof(msg));
|
|
|
|
|
assert(res == 0);
|
|
|
|
|
for (int i = 0 ; i < iterations; i++) {
|
|
|
|
|
ecdsa_verify(curve, pub, sig, msg, sizeof(msg));
|
|
|
|
|
}
|
|
|
|
|
printf("NIST256p1 verifying speed: %0.2f sig/s\n", 500.0f / ((float)(clock() - t) / CLOCKS_PER_SEC));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void bench_ed25519(void)
|
|
|
|
|
void bench_verify_nist256p1_65(int iterations)
|
|
|
|
|
{
|
|
|
|
|
uint8_t sig[64], pub[65], priv[32], pby;
|
|
|
|
|
|
|
|
|
|
const ecdsa_curve *curve = &nist256p1;
|
|
|
|
|
|
|
|
|
|
memcpy(priv, "\xc5\x5e\xce\x85\x8b\x0d\xdd\x52\x63\xf9\x68\x10\xfe\x14\x43\x7c\xd3\xb5\xe1\xfb\xd7\xc6\xa2\xec\x1e\x03\x1f\x05\xe8\x6d\x8b\xd5", 32);
|
|
|
|
|
ecdsa_get_public_key65(curve, priv, pub);
|
|
|
|
|
ecdsa_sign(curve, priv, msg, sizeof(msg), sig, &pby, NULL);
|
|
|
|
|
|
|
|
|
|
for (int i = 0 ; i < iterations; i++) {
|
|
|
|
|
ecdsa_verify(curve, pub, sig, msg, sizeof(msg));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void bench_verify_ed25519(int iterations)
|
|
|
|
|
{
|
|
|
|
|
ed25519_public_key pk;
|
|
|
|
|
ed25519_secret_key sk;
|
|
|
|
|
@ -65,23 +129,12 @@ void bench_ed25519(void)
|
|
|
|
|
ed25519_publickey(sk, pk);
|
|
|
|
|
ed25519_sign(msg, sizeof(msg), sk, pk, sig);
|
|
|
|
|
|
|
|
|
|
clock_t t = clock();
|
|
|
|
|
for (int i = 0 ; i < 500; i++) {
|
|
|
|
|
int res = ed25519_sign_open(msg, sizeof(msg), pk, sig);
|
|
|
|
|
assert(res == 0);
|
|
|
|
|
for (int i = 0 ; i < iterations; i++) {
|
|
|
|
|
ed25519_sign_open(msg, sizeof(msg), pk, sig);
|
|
|
|
|
}
|
|
|
|
|
printf("Ed25519 verifying speed: %0.2f sig/s\n", 500.0f / ((float)(clock() - t) / CLOCKS_PER_SEC));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void test_verify_speed(void)
|
|
|
|
|
{
|
|
|
|
|
prepare_msg();
|
|
|
|
|
bench_secp256k1();
|
|
|
|
|
bench_nist256p1();
|
|
|
|
|
bench_ed25519();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void bench_curve25519(void)
|
|
|
|
|
void bench_multiply_curve25519(int iterations)
|
|
|
|
|
{
|
|
|
|
|
uint8_t result[32];
|
|
|
|
|
uint8_t secret[32];
|
|
|
|
|
@ -90,16 +143,9 @@ void bench_curve25519(void)
|
|
|
|
|
memcpy(secret, "\xc5\x5e\xce\x85\x8b\x0d\xdd\x52\x63\xf9\x68\x10\xfe\x14\x43\x7c\xd3\xb5\xe1\xfb\xd7\xc6\xa2\xec\x1e\x03\x1f\x05\xe8\x6d\x8b\xd5", 32);
|
|
|
|
|
memcpy(basepoint, "\x96\x47\xda\xbe\x1e\xea\xaf\x25\x47\x1e\x68\x0b\x4d\x7c\x6f\xd1\x14\x38\x76\xbb\x77\x59\xd8\x3d\x0f\xf7\xa2\x49\x08\xfd\xda\xbc", 32);
|
|
|
|
|
|
|
|
|
|
clock_t t = clock();
|
|
|
|
|
for (int i = 0 ; i < 500; i++) {
|
|
|
|
|
for (int i = 0 ; i < iterations; i++) {
|
|
|
|
|
curve25519_scalarmult(result, secret, basepoint);
|
|
|
|
|
}
|
|
|
|
|
printf("Curve25519 multiplying speed: %0.2f mul/s\n", 500.0f / ((float)(clock() - t) / CLOCKS_PER_SEC));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void test_multiply_speed(void)
|
|
|
|
|
{
|
|
|
|
|
bench_curve25519();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static HDNode root;
|
|
|
|
|
@ -114,17 +160,12 @@ void bench_ckd_normal(int iterations)
|
|
|
|
|
{
|
|
|
|
|
char addr[MAX_ADDR_SIZE];
|
|
|
|
|
HDNode node;
|
|
|
|
|
clock_t t = clock();
|
|
|
|
|
for (int i = 0; i < iterations; i++) {
|
|
|
|
|
memcpy(&node, &root, sizeof(HDNode));
|
|
|
|
|
hdnode_public_ckd(&node, i);
|
|
|
|
|
hdnode_fill_public_key(&node);
|
|
|
|
|
ecdsa_get_address(node.public_key, 0, addr, sizeof(addr));
|
|
|
|
|
if (i == 0 || i == iterations - 1) {
|
|
|
|
|
printf("address = %s\n", addr);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
printf("CKD normal speed: %0.2f iter/s\n", iterations / ((float)(clock() - t) / CLOCKS_PER_SEC));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void bench_ckd_optimized(int iterations)
|
|
|
|
|
@ -132,26 +173,42 @@ void bench_ckd_optimized(int iterations)
|
|
|
|
|
char addr[MAX_ADDR_SIZE];
|
|
|
|
|
curve_point pub;
|
|
|
|
|
ecdsa_read_pubkey(&secp256k1, root.public_key, &pub);
|
|
|
|
|
clock_t t = clock();
|
|
|
|
|
for (int i = 0; i < iterations; i++) {
|
|
|
|
|
hdnode_public_ckd_address_optimized(&pub, root.chain_code, i, 0, addr, sizeof(addr), false);
|
|
|
|
|
if (i == 0 || i == iterations -1) {
|
|
|
|
|
printf("address = %s\n", addr);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
printf("CKD optim speed: %0.2f iter/s\n", iterations / ((float)(clock() - t) / CLOCKS_PER_SEC));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void test_ckd_speed(int iterations)
|
|
|
|
|
void bench(void (*func)(int), const char *name, int iterations)
|
|
|
|
|
{
|
|
|
|
|
prepare_node();
|
|
|
|
|
bench_ckd_normal(iterations);
|
|
|
|
|
bench_ckd_optimized(iterations);
|
|
|
|
|
clock_t t = clock();
|
|
|
|
|
func(iterations);
|
|
|
|
|
float speed = iterations / ((float)(clock() - t) / CLOCKS_PER_SEC);
|
|
|
|
|
printf("%25s: %8.2f ops/s\n", name, speed);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define BENCH(FUNC, ITER) bench(FUNC, #FUNC, ITER)
|
|
|
|
|
|
|
|
|
|
int main(void) {
|
|
|
|
|
test_verify_speed();
|
|
|
|
|
test_multiply_speed();
|
|
|
|
|
test_ckd_speed(1000);
|
|
|
|
|
|
|
|
|
|
prepare_msg();
|
|
|
|
|
|
|
|
|
|
BENCH(bench_sign_secp256k1, 500);
|
|
|
|
|
BENCH(bench_verify_secp256k1_33, 500);
|
|
|
|
|
BENCH(bench_verify_secp256k1_65, 500);
|
|
|
|
|
|
|
|
|
|
BENCH(bench_sign_nist256p1, 500);
|
|
|
|
|
BENCH(bench_verify_nist256p1_33, 500);
|
|
|
|
|
BENCH(bench_verify_nist256p1_65, 500);
|
|
|
|
|
|
|
|
|
|
BENCH(bench_sign_ed25519, 4000);
|
|
|
|
|
BENCH(bench_verify_ed25519, 4000);
|
|
|
|
|
|
|
|
|
|
BENCH(bench_multiply_curve25519, 4000);
|
|
|
|
|
|
|
|
|
|
prepare_node();
|
|
|
|
|
|
|
|
|
|
BENCH(bench_ckd_normal, 1000);
|
|
|
|
|
BENCH(bench_ckd_optimized, 1000);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
Pavol Rusnak
7 years ago