🖲 Benchmark cryptographic signing and verifying

back/benchmark/benchmark-data-mapper.ts

@@ -8,7 +8,7 @@ export async function benchMarkDataMapper(dataMapper: DataMapper) {
 		createdAt: new Date().toISOString(),
 	};
 
-	const bench = new Bench({ name: "simple benchmark" });
+	const bench = new Bench({ name: "simple benchmark", iterations: 1000 });
 
 	bench.add("Create queuer", () => dataMapper.createQueuer(queuer), {
 		beforeEach() {
@@ -26,6 +26,7 @@ export async function benchMarkDataMapper(dataMapper: DataMapper) {
 		bench.tasks.map(({ name, result }) => ({
 			"Task Name": name,
 			"Average (ms)": Math.floor(result?.mean ?? 0),
+			"p99 (ms)": Math.floor(result?.p99 ?? 0),
 			"Longest (ms)": Math.floor(result?.max ?? 0),
 			"Ops/Sec": Math.floor(result?.hz ?? 0),
 		})),

back/benchmark/benchmark-sign-verify.ts

@@ -0,0 +1,40 @@
+import { Bench } from "tinybench";
+import type { DataMapper } from "core/types/data-mapper";
+import { createKeyPair } from "../utils/create-key-pair.js";
+import { sign } from "../utils/sign.js";
+import { verify } from "../utils/verify.js";
+
+export async function benchmarkSignVerify() {
+	let [publicKey, privateKey] = await createKeyPair();
+	let signed = await sign(publicKey, privateKey, { data: Math.random() });
+
+	let data = { data: Math.random() };
+
+	const bench = new Bench({ name: "simple benchmark", iterations: 2 });
+
+	bench.add("sign", () => sign(publicKey, privateKey, data), {
+		async beforeEach() {
+			[publicKey, privateKey] = await createKeyPair();
+			data = { data: Math.random() };
+		},
+	});
+
+	bench.add("verify", () => verify(signed), {
+		async beforeEach() {
+			[publicKey, privateKey] = await createKeyPair();
+			signed = await sign(publicKey, privateKey, data);
+		},
+	});
+
+	await bench.run();
+
+	console.table(
+		bench.tasks.map(({ name, result }) => ({
+			"Task Name": name,
+			"Average (ms)": Math.floor(result?.mean ?? 0),
+			"p99 (ms)": Math.floor(result?.p99 ?? 0),
+			"Longest (ms)": Math.floor(result?.max ?? 0),
+			"Ops/Sec": Math.floor(result?.hz ?? 0),
+		})),
+	);
+}

back/main.ts

@@ -7,6 +7,7 @@ import { withServerStarted } from "core/fixtures/with-server-started";
 import { createBackContext } from "./utils/create-back-context.js";
 import { asNewPlayerConnect } from "core/automations/as-new-player-connect";
 import { benchMarkDataMapper } from "./benchmark/benchmark-data-mapper.js";
+import { benchmarkSignVerify } from "./benchmark/benchmark-sign-verify.js";
 //import { asPlayerInitiateGame } from "core/automations/as-player-initiate-game";
 
 console.log("Starting...");
@@ -17,6 +18,7 @@ Promise.resolve().then(async () => {
 	const dataMapper = createDataMapper(orm, db);
 
 	await benchMarkDataMapper(dataMapper);
+	await benchmarkSignVerify();
 
 	console.log("Success !");
 });

back/utils/create-back-context.ts

@@ -15,7 +15,7 @@ export function createBackContext(orm: MikroORM, db: Db): BackContext {
 		connections$: createWsServer(),
 		isValidSignature: () => Promise.resolve(true),
 		serverPublicKey,
-		signMessage: (message) => sign(serverPublicKey, message),
+		signMessage: (message) => sign(serverPublicKey, "privateKey", message),
 		lateMatchmakingTimer: (source) => source.pipe(debounceTime(10000)),
 		roundTimer: createRoundTimer(),
 		dataMapper: createDataMapper(orm, db),

back/utils/create-key-pair.ts

@@ -0,0 +1,30 @@
+import { webcrypto } from "node:crypto";
+
+export async function createKeyPair(): Promise<[string, string]> {
+	const keyPair: CryptoKeyPair = await webcrypto.subtle.generateKey(
+		{ name: "ECDSA", namedCurve: "P-384" },
+		true,
+		["verify", "sign"],
+	);
+
+	const publicKeyBuffer: ArrayBuffer = await webcrypto.subtle.exportKey(
+		"spki",
+		keyPair.publicKey,
+	);
+
+	const privateKeyBuffer: ArrayBuffer = await webcrypto.subtle.exportKey(
+		"pkcs8",
+		keyPair.privateKey,
+	);
+
+	const publicKey: string = buf2hex(publicKeyBuffer);
+	const privateKey: string = buf2hex(privateKeyBuffer);
+	return [publicKey, privateKey];
+}
+
+function buf2hex(buffer: ArrayBuffer): string {
+	return [...new Uint8Array(buffer)]
+		.map((x) => x.toString(16))
+		.map((x) => x.padStart(2, "0"))
+		.join("");
+}

back/utils/sign.ts

@@ -3,10 +3,10 @@ import { webcrypto } from "node:crypto";
 
 export async function sign<T>(
 	publicKey: string,
+	privateKeyStr: string,
 	payload: T,
 ): Promise<T & Signed> {
-	const privateKeyStr: string = process.env.SIGNING_PRIVATE_KEY;
-	const privateKeyBuffer: ArrayBuffer = Buffer.from(privateKeyStr, "base64");
+	const privateKeyBuffer: ArrayBuffer = Buffer.from(privateKeyStr, "hex");
 
 	const ecKeyImportParams: EcKeyImportParams = {
 		name: "ECDSA",