Initial project import

tools/v/bench/crypto/ecdsa/ecdsa.c

@@ -0,0 +1,129 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <openssl/ec.h>
+#include <openssl/ecdsa.h>
+#include <openssl/obj_mac.h>
+#include <openssl/sha.h>
+#include <openssl/rand.h>
+#include <sys/time.h>
+
+#define ITERATIONS 1000
+#define MESSAGE "Benchmark message"
+
+// Function to calculate the difference in microseconds between two timevals
+long time_diff_microseconds(struct timeval start, struct timeval end) {
+    long seconds = end.tv_sec - start.tv_sec;
+    long useconds = end.tv_usec - start.tv_usec;
+    return seconds * 1000000 + useconds;
+}
+
+int main() {
+    int iterations = ITERATIONS;
+    struct timeval start, end;
+    long total_gen_time = 0;
+    long total_sign_time = 0;
+    long total_verify_time = 0;
+    long avg_gen_time, avg_sign_time, avg_verify_time;
+
+    // Benchmarking key generation
+    printf("Benchmarking key generation...\n");
+    for(int i = 0; i < iterations; i++) {
+        gettimeofday(&start, NULL);
+
+        // Create a new EC_KEY object with the P-256 curve
+        EC_KEY *key = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
+        if (key == NULL) {
+            fprintf(stderr, "Error creating EC_KEY object.\n");
+            exit(EXIT_FAILURE);
+        }
+
+        // Generate the key
+        if (EC_KEY_generate_key(key) != 1) {
+            fprintf(stderr, "Error generating EC key.\n");
+            EC_KEY_free(key);
+            exit(EXIT_FAILURE);
+        }
+
+        gettimeofday(&end, NULL);
+        total_gen_time += time_diff_microseconds(start, end);
+
+        // Free the key
+        EC_KEY_free(key);
+    }
+    avg_gen_time = total_gen_time / iterations;
+    printf("Average key generation time: %ld µs\n", avg_gen_time);
+
+    // Generate a single key for signing and verification
+    EC_KEY *priv_key = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
+    if (priv_key == NULL) {
+        fprintf(stderr, "Error creating EC_KEY object.\n");
+        exit(EXIT_FAILURE);
+    }
+    if (EC_KEY_generate_key(priv_key) != 1) {
+        fprintf(stderr, "Error generating EC key.\n");
+        EC_KEY_free(priv_key);
+        exit(EXIT_FAILURE);
+    }
+
+    // Prepare the message hash
+    unsigned char hash[SHA256_DIGEST_LENGTH];
+    SHA256((unsigned char*)MESSAGE, strlen(MESSAGE), hash);
+
+    // Benchmarking signing
+    printf("Benchmarking signing...\n");
+    for(int i = 0; i < iterations; i++) {
+        gettimeofday(&start, NULL);
+
+        ECDSA_SIG *signature = ECDSA_do_sign(hash, SHA256_DIGEST_LENGTH, priv_key);
+        if (signature == NULL) {
+            fprintf(stderr, "Error signing message.\n");
+            EC_KEY_free(priv_key);
+            exit(EXIT_FAILURE);
+        }
+
+        gettimeofday(&end, NULL);
+        total_sign_time += time_diff_microseconds(start, end);
+
+        // Free the signature
+        ECDSA_SIG_free(signature);
+    }
+    avg_sign_time = total_sign_time / iterations;
+    printf("Average sign time: %ld µs\n", avg_sign_time);
+
+    // Create a signature for verification benchmarking
+    ECDSA_SIG *signature = ECDSA_do_sign(hash, SHA256_DIGEST_LENGTH, priv_key);
+    if (signature == NULL) {
+        fprintf(stderr, "Error signing message for verification.\n");
+        EC_KEY_free(priv_key);
+        exit(EXIT_FAILURE);
+    }
+
+    // Benchmarking verification
+    printf("Benchmarking verification...\n");
+    for(int i = 0; i < iterations; i++) {
+        gettimeofday(&start, NULL);
+
+        int verify_status = ECDSA_do_verify(hash, SHA256_DIGEST_LENGTH, signature, priv_key);
+
+        gettimeofday(&end, NULL);
+        total_verify_time += time_diff_microseconds(start, end);
+
+        if (verify_status != 1) {
+            fprintf(stderr, "Signature verification failed.\n");
+            ECDSA_SIG_free(signature);
+            EC_KEY_free(priv_key);
+            exit(EXIT_FAILURE);
+        }
+    }
+    avg_verify_time = total_verify_time / iterations;
+    printf("Average verify time: %ld µs\n", avg_verify_time);
+
+    // Cleanup
+    ECDSA_SIG_free(signature);
+    EC_KEY_free(priv_key);
+
+    return 0;
+}
+

tools/v/bench/crypto/ecdsa/ecdsa.go

@@ -0,0 +1,63 @@
+package main
+
+import (
+    "crypto/ecdsa"
+    "crypto/elliptic"
+    "crypto/rand"
+    "fmt"
+    "time"
+)
+
+func main() {
+    iterations := 1000
+
+    fmt.Println("Benchmarking key generation...")
+    var totalGenTime int64
+    for i := 0; i < iterations; i++ {
+        start := time.Now()
+        _, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+        if err != nil {
+            panic(err)
+        }
+        totalGenTime += time.Since(start).Microseconds()
+    }
+    avgGenTime := totalGenTime / int64(iterations)
+    fmt.Printf("Average key generation time: %d µs\n", avgGenTime)
+
+    privKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+    if err != nil {
+        panic(err)
+    }
+    message := []byte("Benchmark message")
+
+    fmt.Println("Benchmarking signing...")
+    var totalSignTime int64
+    for i := 0; i < iterations; i++ {
+        start := time.Now()
+        _, _, err := ecdsa.Sign(rand.Reader, privKey, message)
+        if err != nil {
+            panic(err)
+        }
+        totalSignTime += time.Since(start).Microseconds()
+    }
+    avgSignTime := totalSignTime / int64(iterations)
+    fmt.Printf("Average sign time: %d µs\n", avgSignTime)
+
+    r, s, err := ecdsa.Sign(rand.Reader, privKey, message)
+    if err != nil {
+        panic(err)
+    }
+
+    pubKey := &privKey.PublicKey
+
+    fmt.Println("Benchmarking verification...")
+    var totalVerifyTime int64
+    for i := 0; i < iterations; i++ {
+        start := time.Now()
+        ecdsa.Verify(pubKey, message, r, s)
+        totalVerifyTime += time.Since(start).Microseconds()
+    }
+    avgVerifyTime := totalVerifyTime / int64(iterations)
+    fmt.Printf("Average verify time: %d µs\n", avgVerifyTime)
+}
+

tools/v/bench/crypto/ecdsa/ecdsa.v

@@ -0,0 +1,44 @@
+import time
+import crypto.ecdsa
+
+fn main() {
+	iterations := 1000
+
+	println('Benchmarking key generation...')
+	mut total_gen_time := i64(0)
+	for _ in 0 .. iterations {
+		sw := time.new_stopwatch()
+		_, _ := ecdsa.generate_key() or { panic(err) }
+		elapsed := sw.elapsed().microseconds()
+		total_gen_time += elapsed
+	}
+	avg_gen_time := total_gen_time / iterations
+	println('Average key generation time: ${avg_gen_time} µs')
+
+	pub_key, priv_key := ecdsa.generate_key() or { panic(err) }
+	message := 'Benchmark message'.bytes()
+
+	println('Benchmarking signing...')
+	mut total_sign_time := i64(0)
+	for _ in 0 .. iterations {
+		sw := time.new_stopwatch()
+		_ := priv_key.sign(message) or { panic(err) }
+		elapsed := sw.elapsed().microseconds()
+		total_sign_time += elapsed
+	}
+	avg_sign_time := total_sign_time / iterations
+	println('Average sign time: ${avg_sign_time} µs')
+
+	sig := priv_key.sign(message) or { panic(err) }
+
+	println('Benchmarking verification...')
+	mut total_verify_time := i64(0)
+	for _ in 0 .. iterations {
+		sw := time.new_stopwatch()
+		_ := pub_key.verify(message, sig) or { panic(err) }
+		elapsed := sw.elapsed().microseconds()
+		total_verify_time += elapsed
+	}
+	avg_verify_time := total_verify_time / iterations
+	println('Average verify time: ${avg_verify_time} µs')
+}