@quenty/ellipticcurvecryptography 1.5.0 → 1.6.0

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [1.6.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/ellipticcurvecryptography@1.5.0...@quenty/ellipticcurvecryptography@1.6.0) (2025-04-02)
+
+
+### Bug Fixes
+
+* Fix broken tests ([96485ff](https://github.com/Quenty/NevermoreEngine/commit/96485ff69dbba007d13ea4b5fe82f67244fda14c))
+
+
+
+
+
 # [1.5.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/ellipticcurvecryptography@1.4.0...@quenty/ellipticcurvecryptography@1.5.0) (2024-09-25)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/ellipticcurvecryptography",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Elliptic curve cryptography forked from BoatBomber, forked from ComputerCraft",
   "keywords": [
     "Roblox",
@@ -28,5 +28,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "41715b15e2b48b2d22ff4f5277a8d4b7a0d32ef3"
+  "gitHead": "e8ea56930e65322fcffc05a1556d5df988068f0b"
 }

package/src/Shared/EllipticCurveCryptography/benchmark.spec.lua

@@ -1,63 +1,67 @@
---!native
+local require = require(game:GetService("ServerScriptService"):FindFirstChild("LoaderUtils", true).Parent).bootstrapStory(script)
+
+local Jest = require("Jest")
 local ecc = require(script.Parent)
 
-warn("Running EllipticCurveCryptography benchmark...")
+local describe = Jest.Globals.describe
+local expect = Jest.Globals.expect
+local it = Jest.Globals.it
 
--- selene: allow(unused_variable)
-local function printBytes(byteTable)
-	return table.concat(byteTable, "-")
+-- helper function
+local function generateTestData(size)
+    local data = table.create(size)
+    for x = 1, size do
+        data[x] = math.random(35, 120)
+    end
+    return string.char(table.unpack(data))
 end
 
--- Each machine generates their tokens
-local serverPrivate, serverPublic = ecc.keypair(ecc.random.random())
-local clientPrivate, clientPublic = ecc.keypair(ecc.random.random())
-
--- print("\nserverPrivate:",printBytes(serverPrivate),"\nserverPublic:",printBytes(serverPublic))
--- print("\nclientPrivate:",printBytes(clientPrivate),"\nclientPublic:",printBytes(clientPublic))
+describe("EllipticCurveCryptography Performance", function()
+    local N, S = 500, 100 -- N iterations, S bytes per payload
 
--- They share their publics and exchange to shared secret
-local serverSecret = ecc.exchange(serverPrivate, clientPublic)
-local clientSecret = ecc.exchange(clientPrivate, serverPublic)
+    it(string.format("should efficiently process %d payloads of %d bytes", N, S), function()
+        local serverPrivate, serverPublic = ecc.keypair(DateTime.now().UnixTimestamp)
+        local clientPrivate, clientPublic = ecc.keypair(DateTime.now().UnixTimestamp)
+        local serverSecret = ecc.exchange(serverPrivate, clientPublic)
+        local clientSecret = ecc.exchange(clientPrivate, serverPublic)
 
---print("\nsharedSecret:", printBytes(serverSecret))
+        -- verify shared secret matches before benchmarking
+        expect(tostring(serverSecret)).toEqual(tostring(clientSecret))
 
-assert(tostring(serverSecret) == tostring(clientSecret), "sharedSecret must be identical to both parties")
+        local encryptSum, decryptSum = 0, 0
 
--- warn("encrypting and signing payload(s)")
+        for _ = 1, N do
+            local payload = generateTestData(S)
 
-local N, S = 500, 100
-local encryptSum, decryptSum = 0, 0
-local data = table.create(S)
-for _ = 1, N do
-	for x = 1, S do
-		data[x] = math.random(35, 120)
-	end
-	local payload = string.char(table.unpack(data))
+            -- measure encryption + signing
+            local start = os.clock()
+            local ciphertext = ecc.encrypt(payload, clientSecret)
+            local sig = ecc.sign(clientPrivate, payload)
+            encryptSum += os.clock() - start
 
-	local start = os.clock()
-	local ciphertext = ecc.encrypt(payload, clientSecret)
-	local sig = ecc.sign(clientPrivate, payload)
-	encryptSum += os.clock() - start
+            -- measure decryption + verification
+            start = os.clock()
+            local plaintext = ecc.decrypt(ciphertext, serverSecret)
+            ecc.verify(clientPublic, plaintext, sig)
+            decryptSum += os.clock() - start
+        end
 
-	start = os.clock()
-	local plaintext = ecc.decrypt(ciphertext, serverSecret)
-	ecc.verify(clientPublic, plaintext, sig)
+        -- calculate metrics
+        local encryptTotal = encryptSum * 1000 -- convert to ms
+        local encryptAvg = (encryptSum / N) * 1000
+        local decryptTotal = decryptSum * 1000
+        local decryptAvg = (decryptSum / N) * 1000
 
-	decryptSum += os.clock() - start
-
-	--print("    Bench run %d done", i)
-end
+        -- performance expectations
+        -- expect(encryptAvg).toBeLessThan(1) -- expect sub-1ms average for encryption
+        -- expect(decryptAvg).toBeLessThan(1) -- expect sub-1ms average for decryption
 
-print(
-	string.format(
-		"    Dataset: %d payloads of %d bytes of random data.\nResults:\n       Encrypt & Sign took %.2fms in total with a %.2fms avg.\n       Decrypt & Verify took %.2fms in total with a %.2fms avg.",
-		N,
-		S,
-		encryptSum * 1000,
-		(encryptSum / N) * 1000,
-		decryptSum * 1000,
-		(decryptSum / N) * 1000
-	)
-)
-
-return true
+        -- log performance results (optional, but useful for debugging)
+        print(string.format(
+            "benchmark results:\n" ..
+            "encrypt & sign: %.2fms total, %.2fms avg\n" ..
+            "decrypt & verify: %.2fms total, %.2fms avg",
+            encryptTotal, encryptAvg, decryptTotal, decryptAvg
+        ))
+    end, 30000)
+end)

package/src/Shared/EllipticCurveCryptography/testing.spec.lua

@@ -1,54 +1,51 @@
+local require = require(game:GetService("ServerScriptService"):FindFirstChild("LoaderUtils", true).Parent).bootstrapStory(script)
+
+local Jest = require("Jest")
 local ecc = require(script.Parent)
 
-warn("Running EllipticCurveCryptography tests...")
+local describe = Jest.Globals.describe
+local expect = Jest.Globals.expect
+local it = Jest.Globals.it
 
--- selene: allow(unused_variable)
-local function printBytes(byteTable)
-	return table.concat(byteTable, "-")
+local function generateTestData(size)
+    local data = table.create(size)
+    for x = 1, size do
+        data[x] = math.random(35, 120)
+    end
+    return string.char(table.unpack(data))
 end
 
--- Each machine generates their tokens
-local serverPrivate, serverPublic = ecc.keypair(ecc.random.random())
-local clientPrivate, clientPublic = ecc.keypair(ecc.random.random())
-
--- print("\nserverPrivate:",printBytes(serverPrivate),"\nserverPublic:",printBytes(serverPublic))
--- print("\nclientPrivate:",printBytes(clientPrivate),"\nclientPublic:",printBytes(clientPublic))
-
--- They share their publics and exchange to shared secret
-local serverSecret = ecc.exchange(serverPrivate, clientPublic)
-local clientSecret = ecc.exchange(clientPrivate, serverPublic)
-
---print("\nsharedSecret:", printBytes(serverSecret))
+describe("EllipticCurveCryptography", function()
+    it("should generate matching shared secrets", function()
+        local serverPrivate, serverPublic = ecc.keypair(DateTime.now().UnixTimestamp)
+        local clientPrivate, clientPublic = ecc.keypair(DateTime.now().UnixTimestamp)
 
-assert(tostring(serverSecret) == tostring(clientSecret), "sharedSecret must be identical to both parties")
+        local serverSecret = ecc.exchange(serverPrivate, clientPublic)
+        local clientSecret = ecc.exchange(clientPrivate, serverPublic)
 
-local data = table.create(50)
-for _ = 1, 100 do
-	for x = 1, 50 do
-		data[x] = math.random(35, 120)
-	end
-	local payload = string.char(table.unpack(data))
+        expect(tostring(serverSecret)).toEqual(tostring(clientSecret))
+    end)
 
-	-- Client encrypts and signs their password payload
-	local ciphertext = ecc.encrypt(payload, clientSecret)
-	local sig = ecc.sign(clientPrivate, payload)
+    it("should successfully encrypt, decrypt, and verify multiple payloads", function()
+        local serverPrivate, serverPublic = ecc.keypair(DateTime.now().UnixTimestamp)
+        local clientPrivate, clientPublic = ecc.keypair(DateTime.now().UnixTimestamp)
+        local serverSecret = ecc.exchange(serverPrivate, clientPublic)
+        local clientSecret = ecc.exchange(clientPrivate, serverPublic)
 
-	-- print("\nencryptedPayload:",printBytes(ciphertext),"\nsignature:",printBytes(sig))
+        for _ = 1, 100 do
+            local payload = generateTestData(50)
 
-	-- warn("decrypting and verifying payload")
-	-- Server recieves and validates
-	local plaintext = ecc.decrypt(ciphertext, serverSecret)
-	local validate = ecc.verify(clientPublic, plaintext, sig)
-
-	-- print("\ndecryptedPayload:",plaintext,"\nverified:",validate)
-
-	assert(payload ~= tostring(ciphertext), "Encrypted payload must be different from plaintext")
-	assert(payload == tostring(plaintext), "Decrypted data must equal the original payload")
-	assert(validate, "Signature must verify decrypted data")
-
-	--print("    Test run %d passed", i)
-end
+            -- encrypt and sign
+            local ciphertext = ecc.encrypt(payload, clientSecret)
+            local sig = ecc.sign(clientPrivate, payload)
 
-print("    EllipticCurveCryptography tests passed")
+            -- decrypt and verify
+            local plaintext = ecc.decrypt(ciphertext, serverSecret)
+            local validate = ecc.verify(clientPublic, plaintext, sig)
 
-return true
+            expect(payload).never.toEqual(tostring(ciphertext))
+            expect(payload).toEqual(tostring(plaintext))
+            expect(validate).toBe(true)
+        end
+    end)
+end)