@quenty/ellipticcurvecryptography 1.12.0 → 1.14.0

package/CHANGELOG.md

@@ -3,6 +3,18 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [1.14.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/ellipticcurvecryptography@1.13.0...@quenty/ellipticcurvecryptography@1.14.0) (2026-07-23)
+
+### Bug Fixes
+
+- **ellipticcurvecryptography:** move specs out of ModuleScript folder ([eb31399](https://github.com/Quenty/NevermoreEngine/commit/eb31399c5e25a790ede55b395ed7972d038b5e6a))
+
+# [1.13.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/ellipticcurvecryptography@1.12.0...@quenty/ellipticcurvecryptography@1.13.0) (2026-07-14)
+
+### Features
+
+- **ellipticcurvecryptography:** convert package to --!strict ([48e814a](https://github.com/Quenty/NevermoreEngine/commit/48e814abb5f01f54627dd4f827a287fb98f405bc))
+
 # [1.12.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/ellipticcurvecryptography@1.11.0...@quenty/ellipticcurvecryptography@1.12.0) (2026-05-29)
 
 **Note:** Version bump only for package @quenty/ellipticcurvecryptography

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/ellipticcurvecryptography",
-  "version": "1.12.0",
+  "version": "1.14.0",
   "description": "Elliptic curve cryptography forked from BoatBomber, forked from ComputerCraft",
   "keywords": [
     "Roblox",
@@ -29,11 +29,11 @@
     "BoatBomber"
   ],
   "dependencies": {
-    "@quenty/nevermore-test-runner": "1.4.0",
+    "@quenty/nevermore-test-runner": "1.5.0",
     "@quentystudios/jest-lua": "3.10.0-quenty.2"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "f4a374a0a294ee8900aa5cb68ab138b0acf3e0ae"
+  "gitHead": "1de37218a2bedb8e3f8614a2e09bba9eddc812da"
 }

package/src/Shared/EllipticCurveCryptography/arith.lua

@@ -1,9 +1,12 @@
---!nonstrict
+--!strict
 -- Big integer arithmetic for 168-bit (and 336-bit) numbers
 -- Numbers are represented as little-endian tables of 24-bit integers
 local twoPower = require(script.Parent.twoPower)
 
-local function isEqual(a, b)
+type BigInt = { number }
+type DoubleInt = { number }
+
+local function isEqual(a: BigInt, b: BigInt): boolean
 	return a[1] == b[1]
 		and a[2] == b[2]
 		and a[3] == b[3]
@@ -13,7 +16,7 @@ local function isEqual(a, b)
 		and a[7] == b[7]
 end
 
-local function compare(a, b)
+local function compare(a: BigInt, b: BigInt): number
 	for i = 7, 1, -1 do
 		if a[i] > b[i] then
 			return 1
@@ -25,7 +28,7 @@ local function compare(a, b)
 	return 0
 end
 
-local function add(a, b)
+local function add(a: BigInt, b: BigInt): BigInt
 	-- c7 may be greater than 2^24 before reduction
 	local c1 = a[1] + b[1]
 	local c2 = a[2] + b[2]
@@ -63,7 +66,7 @@ local function add(a, b)
 	return { c1, c2, c3, c4, c5, c6, c7 }
 end
 
-local function sub(a, b)
+local function sub(a: BigInt, b: BigInt): BigInt
 	-- c7 may be negative before reduction
 	local c1 = a[1] - b[1]
 	local c2 = a[2] - b[2]
@@ -101,7 +104,7 @@ local function sub(a, b)
 	return { c1, c2, c3, c4, c5, c6, c7 }
 end
 
-local function rShift(a)
+local function rShift(a: BigInt): BigInt
 	local c1 = a[1]
 	local c2 = a[2]
 	local c3 = a[3]
@@ -134,7 +137,7 @@ local function rShift(a)
 	return { c1, c2, c3, c4, c5, c6, c7 }
 end
 
-local function addDouble(a, b)
+local function addDouble(a: DoubleInt, b: DoubleInt): DoubleInt
 	-- a and b are 336-bit integers (14 words)
 	local c1 = a[1] + b[1]
 	local c2 = a[2] + b[2]
@@ -207,7 +210,7 @@ local function addDouble(a, b)
 	return { c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14 }
 end
 
-local function mult(a, b, half_multiply)
+local function mult(a: BigInt, b: BigInt, half_multiply: boolean): DoubleInt
 	local a1, a2, a3, a4, a5, a6, a7 = a[1], a[2], a[3], a[4], a[5], a[6], a[7]
 	local b1, b2, b3, b4, b5, b6, b7 = b[1], b[2], b[3], b[4], b[5], b[6], b[7]
 
@@ -218,7 +221,13 @@ local function mult(a, b, half_multiply)
 	local c5 = a1 * b5 + a2 * b4 + a3 * b3 + a4 * b2 + a5 * b1
 	local c6 = a1 * b6 + a2 * b5 + a3 * b4 + a4 * b3 + a5 * b2 + a6 * b1
 	local c7 = a1 * b7 + a2 * b6 + a3 * b5 + a4 * b4 + a5 * b3 + a6 * b2 + a7 * b1
-	local c8, c9, c10, c11, c12, c13, c14
+	local c8: number = 0
+	local c9: number = 0
+	local c10: number = 0
+	local c11: number = 0
+	local c12: number = 0
+	local c13: number = 0
+	local c14: number = 0
 	if not half_multiply then
 		c8 = a2 * b7 + a3 * b6 + a4 * b5 + a5 * b4 + a6 * b3 + a7 * b2
 		c9 = a3 * b7 + a4 * b6 + a5 * b5 + a6 * b4 + a7 * b3
@@ -277,7 +286,7 @@ local function mult(a, b, half_multiply)
 	return { c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14 }
 end
 
-local function square(a)
+local function square(a: BigInt): DoubleInt
 	-- returns a 336-bit integer (14 words)
 	local a1, a2, a3, a4, a5, a6, a7 = a[1], a[2], a[3], a[4], a[5], a[6], a[7]
 
@@ -340,8 +349,8 @@ local function square(a)
 	return { c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14 }
 end
 
-local function encodeInt(a)
-	local enc = table.create(21)
+local function encodeInt(a: BigInt): { number }
+	local enc: { number } = table.create(21)
 
 	for i = 1, 7 do
 		local word = a[i]
@@ -354,9 +363,9 @@ local function encodeInt(a)
 	return enc
 end
 
-local function decodeInt(enc)
-	local a = {}
-	local encCopy = table.create(21)
+local function decodeInt(enc: { number }): BigInt
+	local a: BigInt = {}
+	local encCopy: { number } = table.create(21)
 
 	for i = 1, 21 do
 		local byte = enc[i]
@@ -379,26 +388,27 @@ local function decodeInt(enc)
 	return a
 end
 
-local function mods(d, w)
-	local result = d[1] % twoPower[w]
+local function mods(d: BigInt, w: number): number
+	local result = d[1] % (twoPower :: any)[w]
 
-	if result >= twoPower[w - 1] then
-		result -= twoPower[w]
+	if result >= (twoPower :: any)[w - 1] then
+		result -= (twoPower :: any)[w]
 	end
 
 	return result
 end
 
 -- Represents a 168-bit number as the (2^w)-ary Non-Adjacent Form
-local function NAF(d, w)
-	local t, t_len = {}, 0
-	local newD = { table.unpack(d) }
+local function NAF(d: BigInt, w: number): { number }
+	local t: { number } = {}
+	local t_len = 0
+	local newD: BigInt = { table.unpack(d) }
 
 	for _ = 1, 168 do
 		if newD[1] % 2 == 1 then
 			t_len += 1
 			t[t_len] = mods(newD, w)
-			newD = sub(newD, { t[#t], 0, 0, 0, 0, 0, 0 })
+			newD = sub(newD, { t[t_len], 0, 0, 0, 0, 0, 0 })
 		else
 			t_len += 1
 			t[t_len] = 0

package/src/Shared/EllipticCurveCryptography/chacha20.lua

@@ -1,4 +1,4 @@
---!nonstrict
+--!strict
 --!native
 
 -- Chacha20 cipher in ComputerCraft
@@ -8,7 +8,7 @@
 -- http://www.computercraft.info/forums2/index.php?/user/12870-anavrins
 -- http://pastebin.com/GPzf9JSa
 -- Last update: April 17, 2017
-local twoPower = require(script.Parent.twoPower)
+local twoPower: any = require(script.Parent.twoPower)
 local util = require(script.Parent.util)
 
 local bxor = bit32.bxor
@@ -20,13 +20,13 @@ local mod = 2 ^ 32
 local tau = table.pack(string.byte("expand 16-byte k", 1, -1))
 local sigma = table.pack(string.byte("expand 32-byte k", 1, -1))
 
-local function rotl(n, b)
+local function rotl(n: number, b: number): number
 	local s = n / twoPower[32 - b]
 	local f = s % 1
 	return (s - f) + f * mod
 end
 
-local function quarterRound(s, a, b, c, d)
+local function quarterRound(s: { number }, a: number, b: number, c: number, d: number): { number }
 	s[a] = (s[a] + s[b]) % mod
 	s[d] = rotl(bxor(s[d], s[a]), 16)
 	s[c] = (s[c] + s[d]) % mod
@@ -38,8 +38,8 @@ local function quarterRound(s, a, b, c, d)
 	return s
 end
 
-local function hashBlock(state, rnd)
-	local s = { table.unpack(state) }
+local function hashBlock(state: { number }, rnd: number): { number }
+	local s: { number } = { table.unpack(state) }
 	for i = 1, rnd do
 		local r = i % 2 == 1
 		s = r and quarterRound(s, 1, 5, 9, 13) or quarterRound(s, 1, 6, 11, 16)
@@ -55,17 +55,17 @@ local function hashBlock(state, rnd)
 	return s
 end
 
-local function LE_toInt(bs, i)
+local function LE_toInt(bs: { number }, i: number): number
 	return (bs[i + 1] or 0)
 		+ blshift((bs[i + 2] or 0), 8)
 		+ blshift((bs[i + 3] or 0), 16)
 		+ blshift((bs[i + 4] or 0), 24)
 end
 
-local function initState(key, nonce, counter)
+local function initState(key: { number }, nonce: { number }, counter: number): { number }
 	local isKey256 = #key == 32
-	local const = isKey256 and sigma or tau
-	local state = table.create(16)
+	local const: { number } = isKey256 and sigma or tau
+	local state: { number } = table.create(16)
 
 	state[1] = LE_toInt(const, 0)
 	state[2] = LE_toInt(const, 4)
@@ -89,8 +89,9 @@ local function initState(key, nonce, counter)
 	return state
 end
 
-local function serialize(state)
-	local r, len_r = table.create(16), 0
+local function serialize(state: { number }): { number }
+	local r: { number } = table.create(16)
+	local len_r = 0
 	for i = 1, 16 do
 		r[len_r + 1] = band(state[i], 0xFF)
 		r[len_r + 2] = band(brshift(state[i], 8), 0xFF)
@@ -102,24 +103,34 @@ local function serialize(state)
 	return r
 end
 
-local function crypt(data, key, nonce, cntr, round)
+export type ByteTable = typeof(setmetatable({} :: { number }, {} :: typeof(util.byteTableMT)))
+
+local function crypt(
+	data: string | { number },
+	key: { number },
+	nonce: { number },
+	cntr: number?,
+	round: number?
+): ByteTable
 	assert(type(key) == "table", "ChaCha20: Invalid key format (" .. type(key) .. "), must be table")
 	assert(type(nonce) == "table", "ChaCha20: Invalid nonce format (" .. type(nonce) .. "), must be table")
 	assert(#key == 16 or #key == 32, "ChaCha20: Invalid key length (" .. #key .. "), must be 16 or 32")
 	assert(#nonce == 12, "ChaCha20: Invalid nonce length (" .. #nonce .. "), must be 12")
 
-	local newData = type(data) == "table" and { table.unpack(data) } or util.stringToByteArray(data)
-	cntr = tonumber(cntr) or 1
-	round = tonumber(round) or 20
+	local newData: { number } = type(data) == "table" and { table.unpack(data :: { number }) }
+		or util.stringToByteArray(data :: string)
+	local counter = tonumber(cntr) or 1
+	local rounds = tonumber(round) or 20
 
-	local out, out_len = {}, 0
-	local state = initState(key, nonce, cntr)
+	local out: { number } = {}
+	local out_len = 0
+	local state = initState(key, nonce, counter)
 	local blockAmt = math.floor(#newData / 64)
 	for i = 0, blockAmt do
-		local ks = serialize(hashBlock(state, round))
+		local ks = serialize(hashBlock(state, rounds))
 		state[13] = (state[13] + 1) % mod
 
-		local block = table.create(64)
+		local block: { number } = table.create(64)
 		for j = 1, 64 do
 			block[j] = newData[(i * 64) + j]
 		end

package/src/Shared/EllipticCurveCryptography/curve.lua

@@ -1,4 +1,4 @@
---!nonstrict
+--!strict
 --!native
 
 --[=[
@@ -49,7 +49,7 @@ local montgomeryModP = modp.montgomeryModP
 local expModP = modp.expModP
 local inverseMontgomeryModQ = modq.inverseMontgomeryModQ
 
-local pointMT
+local pointMT: any
 local ZERO = table.create(7, 0)
 local ONE = montgomeryModP({ 1, 0, 0, 0, 0, 0, 0 })
 
@@ -193,9 +193,9 @@ end
 local function scalarMult(multiplier, P1)
 	-- w = 5
 	local naf = NAF(multiplier, 5)
-	local PTable = { P1 }
+	local PTable: { any } = { P1 }
 	local P2 = pointDouble(P1)
-	local Q = { table.create(7, 0), { table.unpack(ONE) }, { table.unpack(ONE) } }
+	local Q: any = { table.create(7, 0), { table.unpack(ONE) }, { table.unpack(ONE) } }
 
 	for i = 3, 31, 2 do
 		PTable[i] = pointAdd(PTable[i - 2], P2)
@@ -215,14 +215,14 @@ end
 
 -- Lookup table 4-ary NAF method for scalar multiplication by G.
 -- Precomputations for the regular NAF method are done before the multiplication.
-local GTable = { G }
+local GTable: { any } = { G }
 for i = 2, 168 do
 	GTable[i] = pointDouble(GTable[i - 1])
 end
 
 local function scalarMultG(multiplier)
 	local naf = NAF(multiplier, 2)
-	local Q = { table.create(7, 0), { table.unpack(ONE) }, { table.unpack(ONE) } }
+	local Q: any = { table.create(7, 0), { table.unpack(ONE) }, { table.unpack(ONE) } }
 
 	for i = 1, 168 do
 		if naf[i] == 1 then
@@ -237,7 +237,7 @@ end
 
 -- Point compression and encoding.
 -- Compresses curve points to 22 bytes.
-local function pointEncode(P1)
+local function pointEncode(P1: any)
 	P1 = pointScale(P1)
 	local result = {}
 	local x, y = P1[1], P1[2]
@@ -321,7 +321,7 @@ pointMT = {
 		return pointIsEqual(P1, P2)
 	end,
 
-	__mul = function(P1, s)
+	__mul = function(P1: any, s: any)
 		if type(P1) == "number" then
 			return s * P1
 		end

package/src/Shared/EllipticCurveCryptography/init.lua

@@ -1,4 +1,4 @@
---!nonstrict
+--!strict
 --!native
 
 --[=[
@@ -39,6 +39,9 @@ local modq = require(script.modq)
 local random = require(script.random)
 local sha256 = require(script.sha256)
 local util = require(script.util)
+
+type ByteTable = typeof(setmetatable({} :: { number }, {} :: typeof(util.byteTableMT)))
+
 local EllipticCurveCryptography = {}
 
 EllipticCurveCryptography.chacha20 = chacha20
@@ -52,7 +55,7 @@ EllipticCurveCryptography._byteMetatable = assert(util.byteTableMT, "No byteTabl
 	@param key any
 	@return boolean
 ]=]
-function EllipticCurveCryptography.isByteTable(key)
+function EllipticCurveCryptography.isByteTable(key: any): boolean
 	return type(key) == "table" and getmetatable(key) == EllipticCurveCryptography._byteMetatable
 end
 
@@ -61,14 +64,14 @@ end
 
 	@param value any
 ]=]
-function EllipticCurveCryptography.createByteTable(value)
+function EllipticCurveCryptography.createByteTable(value: { number }): ByteTable
 	assert(type(value) == "table", "Bad value")
 
 	return setmetatable(table.clone(value), EllipticCurveCryptography._byteMetatable)
 end
 
-function EllipticCurveCryptography._getNonceFromEpoch()
-	local nonce = table.create(12)
+function EllipticCurveCryptography._getNonceFromEpoch(): { number }
+	local nonce: { number } = table.create(12)
 	local epoch = DateTime.now().UnixTimestampMillis
 	for i = 1, 12 do
 		nonce[i] = epoch % 256
@@ -98,23 +101,23 @@ end
 	@param key ByteTable
 	@return ByteTable
 ]=]
-function EllipticCurveCryptography.encrypt(data, key)
+function EllipticCurveCryptography.encrypt(data: string | ByteTable, key: ByteTable): ByteTable
 	assert(type(data) == "string" or EllipticCurveCryptography.isByteTable(data), "Bad data")
 	assert(EllipticCurveCryptography.isByteTable(key), "Bad key")
 
-	local encKey = sha256.hmac("encKey", key)
-	local macKey = sha256.hmac("macKey", key)
+	local encKey = sha256.hmac("encKey", (key :: any) :: { number })
+	local macKey = sha256.hmac("macKey", (key :: any) :: { number })
 	local nonce = EllipticCurveCryptography._getNonceFromEpoch()
 
-	local ciphertext = chacha20.crypt(data, encKey, nonce)
+	local ciphertext = chacha20.crypt(data :: any, (encKey :: any) :: { number }, nonce)
 
-	local result = nonce
-	for _, value in ipairs(ciphertext) do
+	local result: { number } = nonce
+	for _, value in ipairs(ciphertext :: any) do
 		table.insert(result, value)
 	end
 
-	local mac = sha256.hmac(result, macKey)
-	for _, value in ipairs(mac) do
+	local mac = sha256.hmac(result, (macKey :: any) :: { number })
+	for _, value in ipairs((mac :: any) :: { number }) do
 		table.insert(result, value)
 	end
 
@@ -135,21 +138,22 @@ end
 	@param key ByteTable
 	@return ByteTable
 ]=]
-function EllipticCurveCryptography.decrypt(data, key)
+function EllipticCurveCryptography.decrypt(data: string | ByteTable, key: ByteTable): ByteTable
 	assert(type(data) == "string" or EllipticCurveCryptography.isByteTable(data), "Bad data")
 	assert(EllipticCurveCryptography.isByteTable(key), "Bad key")
 
-	local actualData = type(data) == "table" and { table.unpack(data) } or { string.byte(tostring(data), 1, -1) }
-	local encKey = sha256.hmac("encKey", key)
-	local macKey = sha256.hmac("macKey", key)
-	local mac = sha256.hmac({ table.unpack(actualData, 1, #actualData - 32) }, macKey)
+	local actualData: { number } = type(data) == "table" and { table.unpack(data :: any) }
+		or { string.byte(tostring(data), 1, -1) }
+	local encKey = sha256.hmac("encKey", (key :: any) :: { number })
+	local macKey = sha256.hmac("macKey", (key :: any) :: { number })
+	local mac = sha256.hmac({ table.unpack(actualData, 1, #actualData - 32) }, (macKey :: any) :: { number })
 	local messageMac = { table.unpack(actualData, #actualData - 31) }
-	assert(mac:isEqual(messageMac), "invalid mac")
+	assert((mac :: any):isEqual(messageMac), "invalid mac")
 	local nonce = { table.unpack(actualData, 1, 12) }
 	local ciphertext = { table.unpack(actualData, 13, #actualData - 32) }
-	local result = chacha20.crypt(ciphertext, encKey, nonce)
+	local result: ByteTable = chacha20.crypt(ciphertext, (encKey :: any) :: { number }, nonce)
 
-	return setmetatable(result, util.byteTableMT)
+	return result
 end
 
 --[=[
@@ -167,10 +171,10 @@ end
 	@return ByteTable -- privateKey
 	@return ByteTable -- publicKey
 ]=]
-function EllipticCurveCryptography.keypair(seed)
+function EllipticCurveCryptography.keypair(seed: number): (ByteTable, ByteTable)
 	assert(type(seed) == "number", "Bad seed")
 
-	local x
+	local x: any
 	if seed then
 		x = modq.hashModQ(seed)
 	else
@@ -179,8 +183,8 @@ function EllipticCurveCryptography.keypair(seed)
 
 	local Y = curve.G * x
 
-	local privateKey = x:encode()
-	local publicKey = Y:encode()
+	local privateKey: ByteTable = x:encode()
+	local publicKey: ByteTable = Y:encode()
 
 	return privateKey, publicKey
 end
@@ -203,15 +207,15 @@ end
 	@param publicKey ByteTable
 	@return ByteTable
 ]=]
-function EllipticCurveCryptography.exchange(privateKey, publicKey)
+function EllipticCurveCryptography.exchange(privateKey: ByteTable, publicKey: ByteTable): ByteTable
 	assert(EllipticCurveCryptography.isByteTable(privateKey), "Bad privateKey")
 	assert(EllipticCurveCryptography.isByteTable(publicKey), "Bad publicKey")
 
 	local x = modq.decodeModQ(privateKey)
-	local Y = curve.pointDecode(publicKey)
+	local Y = curve.pointDecode(publicKey :: any)
 	local Z = Y * x
 
-	local sharedSecret = sha256.digest(Z:encode())
+	local sharedSecret: ByteTable = sha256.digest(Z:encode())
 
 	return sharedSecret
 end
@@ -227,24 +231,25 @@ end
 	@param message string | EncodedMessage
 	@return ByteTable
 ]=]
-function EllipticCurveCryptography.sign(privateKey, message)
+function EllipticCurveCryptography.sign(privateKey: ByteTable, message: string | ByteTable): ByteTable
 	assert(EllipticCurveCryptography.isByteTable(privateKey), "Bad privateKey")
 	assert(type(message) == "string" or EllipticCurveCryptography.isByteTable(message), "Bad message")
 
-	local actualMessage = type(message) == "table" and string.char(table.unpack(message)) or tostring(message)
-	local actualPrivateKey = type(privateKey) == "table" and string.char(table.unpack(privateKey))
+	local actualMessage = type(message) == "table" and string.char(table.unpack(message :: any)) or tostring(message)
+	local actualPrivateKey = type(privateKey) == "table" and string.char(table.unpack(privateKey :: any))
 		or tostring(privateKey)
 
-	local x = modq.decodeModQ(actualPrivateKey)
-	local k = modq.randomModQ()
+	local x: any = modq.decodeModQ(actualPrivateKey)
+	local k: any = modq.randomModQ()
 	local R = curve.G * k
-	local e = modq.hashModQ(actualMessage .. tostring(R))
+	local e: any = modq.hashModQ(actualMessage .. tostring(R))
 	local s = k - x * e
 
 	e = e:encode()
 	s = s:encode()
 
-	local result, result_len = e, #e
+	local result: { number } = e
+	local result_len = #e
 	for index, value in ipairs(s) do
 		result[result_len + index] = value
 	end
@@ -265,16 +270,20 @@ end
 	@param message ByteTable | string
 	@param signature ByteTable
 ]=]
-function EllipticCurveCryptography.verify(publicKey, message, signature)
+function EllipticCurveCryptography.verify(
+	publicKey: ByteTable,
+	message: string | ByteTable,
+	signature: ByteTable
+): boolean
 	assert(EllipticCurveCryptography.isByteTable(publicKey), "Bad privateKey")
 	assert(type(message) == "string" or EllipticCurveCryptography.isByteTable(message), "Bad message")
 	assert(EllipticCurveCryptography.isByteTable(signature), "Bad signature")
 
-	local actualMessage = type(message) == "table" and string.char(table.unpack(message)) or tostring(message)
+	local actualMessage = type(message) == "table" and string.char(table.unpack(message :: any)) or tostring(message)
 	local sigLen = #signature
-	local Y = curve.pointDecode(publicKey)
-	local e = modq.decodeModQ({ table.unpack(signature, 1, sigLen / 2) })
-	local s = modq.decodeModQ({ table.unpack(signature, sigLen / 2 + 1) })
+	local Y = curve.pointDecode(publicKey :: any)
+	local e = modq.decodeModQ({ table.unpack(signature :: any, 1, sigLen / 2) })
+	local s = modq.decodeModQ({ table.unpack(signature :: any, sigLen / 2 + 1) })
 	local Rv = curve.G * s + Y * e
 	local ev = modq.hashModQ(actualMessage .. tostring(Rv))
 

package/src/Shared/EllipticCurveCryptography/modp.lua

@@ -1,4 +1,4 @@
---!nonstrict
+--!strict
 -- Arithmetic on the finite field of integers modulo p
 -- Where p is the finite field modulus
 local arith = require(script.Parent.arith)
@@ -8,17 +8,20 @@ local addDouble = arith.addDouble
 local mult = arith.mult
 local square = arith.square
 
-local p = { 3, 0, 0, 0, 0, 0, 15761408 }
+type BigInt = { number }
+type DoubleInt = { number }
+
+local p: BigInt = { 3, 0, 0, 0, 0, 0, 15761408 }
 
 -- We're using the Montgomery Reduction for fast modular multiplication.
 -- https://en.wikipedia.org/wiki/Montgomery_modular_multiplication
 -- r = 2^168
 -- p * pInverse = -1 (mod r)
 -- r2 = r * r (mod p)
-local pInverse = { 5592405, 5592405, 5592405, 5592405, 5592405, 5592405, 14800213 }
-local r2 = { 13533400, 837116, 6278376, 13533388, 837116, 6278376, 7504076 }
+local pInverse: BigInt = { 5592405, 5592405, 5592405, 5592405, 5592405, 5592405, 14800213 }
+local r2: BigInt = { 13533400, 837116, 6278376, 13533388, 837116, 6278376, 7504076 }
 
-local function multByP(a)
+local function multByP(a: BigInt): DoubleInt
 	local a1, a2, a3, a4, a5, a6, a7 = a[1], a[2], a[3], a[4], a[5], a[6], a[7]
 
 	local c1 = a1 * 3
@@ -82,7 +85,7 @@ local function multByP(a)
 end
 
 -- Reduces a number from [0, 2p - 1] to [0, p - 1]
-local function reduceModP(a)
+local function reduceModP(a: BigInt): BigInt
 	-- a < p
 	if a[7] < 15761408 or a[7] == 15761408 and a[1] < 3 then
 		return { table.unpack(a) }
@@ -133,11 +136,11 @@ local function reduceModP(a)
 	return { c1, c2, c3, c4, c5, c6, c7 }
 end
 
-local function addModP(a, b)
+local function addModP(a: BigInt, b: BigInt): BigInt
 	return reduceModP(add(a, b))
 end
 
-local function subModP(a, b)
+local function subModP(a: BigInt, b: BigInt): BigInt
 	local result = sub(a, b)
 
 	if result[7] < 0 then
@@ -149,29 +152,29 @@ end
 
 -- Montgomery REDC algorithn
 -- Reduces a number from [0, p^2 - 1] to [0, p - 1]
-local function REDC(T)
+local function REDC(T: DoubleInt): BigInt
 	local m = mult(T, pInverse, true)
-	local t = { table.unpack(addDouble(T, multByP(m)), 8, 14) }
+	local t: BigInt = { table.unpack(addDouble(T, multByP(m)), 8, 14) }
 
 	return reduceModP(t)
 end
 
-local function multModP(a, b)
+local function multModP(a: BigInt, b: BigInt): BigInt
 	-- Only works with a, b in Montgomery form
-	return REDC(mult(a, b))
+	return REDC(mult(a, b, false))
 end
 
-local function squareModP(a)
+local function squareModP(a: BigInt): BigInt
 	-- Only works with a in Montgomery form
 	return REDC(square(a))
 end
 
-local function montgomeryModP(a)
+local function montgomeryModP(a: BigInt): BigInt
 	return multModP(a, r2)
 end
 
-local function inverseMontgomeryModP(a)
-	local newA = { table.unpack(a) }
+local function inverseMontgomeryModP(a: BigInt): BigInt
+	local newA: DoubleInt = { table.unpack(a) }
 
 	for i = 8, 14 do
 		newA[i] = 0
@@ -180,11 +183,11 @@ local function inverseMontgomeryModP(a)
 	return REDC(newA)
 end
 
-local ONE = montgomeryModP({ 1, 0, 0, 0, 0, 0, 0 })
+local ONE: BigInt = montgomeryModP({ 1, 0, 0, 0, 0, 0, 0 })
 
-local function expModP(base, exponentBinary)
-	local newBase = { table.unpack(base) }
-	local result = { table.unpack(ONE) }
+local function expModP(base: BigInt, exponentBinary: { number }): BigInt
+	local newBase: BigInt = { table.unpack(base) }
+	local result: BigInt = { table.unpack(ONE) }
 
 	for i = 1, 168 do
 		if exponentBinary[i] == 1 then

package/src/Shared/EllipticCurveCryptography/modq.lua

@@ -1,4 +1,4 @@
---!nonstrict
+--!strict
 --!native
 
 -- Arithmetic on the Finite Field of Integers modulo q
@@ -8,6 +8,8 @@ local random = require(script.Parent.random)
 local sha256 = require(script.Parent.sha256)
 local util = require(script.Parent.util)
 
+type BigInt = { number }
+
 local isEqual = arith.isEqual
 local compare = arith.compare
 local add = arith.add
@@ -18,11 +20,11 @@ local square = arith.square
 local encodeInt = arith.encodeInt
 local decodeInt = arith.decodeInt
 
-local modQMT
+local modQMT: any
 
-local q = { 9622359, 6699217, 13940450, 16775734, 16777215, 16777215, 3940351 }
+local q: BigInt = { 9622359, 6699217, 13940450, 16775734, 16777215, 16777215, 3940351 }
 -- this isn't an optimization, it just shortens the amount of time I have to scroll
-local qMinusTwoBinary = table.create(166, 1)
+local qMinusTwoBinary: { number } = table.create(166, 1)
 qMinusTwoBinary[2] = 0
 qMinusTwoBinary[4] = 0
 qMinusTwoBinary[6] = 0
@@ -76,59 +78,59 @@ qMinusTwoBinary[162] = 0
 -- r = 2^168
 -- q * qInverse = -1 (mod r)
 -- r2 = r * r (mod q)
-local qInverse = { 15218585, 5740955, 3271338, 9903997, 9067368, 7173545, 6988392 }
-local r2 = { 1336213, 11071705, 9716828, 11083885, 9188643, 1494868, 3306114 }
+local qInverse: BigInt = { 15218585, 5740955, 3271338, 9903997, 9067368, 7173545, 6988392 }
+local r2: BigInt = { 1336213, 11071705, 9716828, 11083885, 9188643, 1494868, 3306114 }
 
 -- Reduces a number from [0, 2q - 1] to [0, q - 1]
-local function reduceModQ(a)
-	local result = { table.unpack(a) }
+local function reduceModQ(a: BigInt): BigInt
+	local result: BigInt = { table.unpack(a) }
 
 	if compare(result, q) >= 0 then
 		result = sub(result, q)
 	end
 
-	return setmetatable(result, modQMT)
+	return setmetatable(result, modQMT) :: any
 end
 
-local function addModQ(a, b)
+local function addModQ(a: BigInt, b: BigInt): BigInt
 	return reduceModQ(add(a, b))
 end
 
-local function subModQ(a, b)
-	local result = sub(a, b)
+local function subModQ(a: BigInt, b: BigInt): BigInt
+	local result: BigInt = sub(a, b)
 
 	if result[7] < 0 then
 		result = add(result, q)
 	end
 
-	return setmetatable(result, modQMT)
+	return setmetatable(result, modQMT) :: any
 end
 
 -- Montgomery REDC algorithn
 -- Reduces a number from [0, q^2 - 1] to [0, q - 1]
-local function REDC(T)
-	local m = { table.unpack(mult({ table.unpack(T, 1, 7) }, qInverse, true), 1, 7) }
-	local t = { table.unpack(addDouble(T, mult(m, q)), 8, 14) }
+local function REDC(T: { number }): BigInt
+	local m: BigInt = { table.unpack(mult({ table.unpack(T, 1, 7) }, qInverse, true), 1, 7) }
+	local t: BigInt = { table.unpack(addDouble(T, mult(m, q, false)), 8, 14) }
 
 	return reduceModQ(t)
 end
 
-local function multModQ(a, b)
+local function multModQ(a: BigInt, b: BigInt): BigInt
 	-- Only works with a, b in Montgomery form
-	return REDC(mult(a, b))
+	return REDC(mult(a, b, false))
 end
 
-local function squareModQ(a)
+local function squareModQ(a: BigInt): BigInt
 	-- Only works with a in Montgomery form
 	return REDC(square(a))
 end
 
-local function montgomeryModQ(a)
+local function montgomeryModQ(a: BigInt): BigInt
 	return multModQ(a, r2)
 end
 
-local function inverseMontgomeryModQ(a)
-	local newA = { table.unpack(a) }
+local function inverseMontgomeryModQ(a: BigInt): BigInt
+	local newA: { number } = { table.unpack(a) }
 
 	for i = 8, 14 do
 		newA[i] = 0
@@ -137,11 +139,11 @@ local function inverseMontgomeryModQ(a)
 	return REDC(newA)
 end
 
-local ONE = montgomeryModQ({ 1, 0, 0, 0, 0, 0, 0 })
+local ONE: BigInt = montgomeryModQ({ 1, 0, 0, 0, 0, 0, 0 })
 
-local function expModQ(base, exponentBinary)
-	local newBase = { table.unpack(base) }
-	local result = { table.unpack(ONE) }
+local function expModQ(base: BigInt, exponentBinary: { number }): BigInt
+	local newBase: BigInt = { table.unpack(base) }
+	local result: BigInt = { table.unpack(ONE) }
 
 	for i = 1, 168 do
 		if exponentBinary[i] == 1 then
@@ -154,9 +156,9 @@ local function expModQ(base, exponentBinary)
 	return result
 end
 
-local function intExpModQ(base, exponent)
-	local newBase = { table.unpack(base) }
-	local result = setmetatable({ table.unpack(ONE) }, modQMT)
+local function intExpModQ(base: BigInt, exponent: number): BigInt
+	local newBase: BigInt = { table.unpack(base) }
+	local result: BigInt = setmetatable({ table.unpack(ONE) }, modQMT) :: any
 
 	if exponent < 0 then
 		newBase = expModQ(newBase, qMinusTwoBinary)
@@ -175,46 +177,46 @@ local function intExpModQ(base, exponent)
 	return result
 end
 
-local function encodeModQ(a)
+local function encodeModQ(a: BigInt): { number }
 	local result = encodeInt(a)
 
-	return setmetatable(result, util.byteTableMT)
+	return setmetatable(result, util.byteTableMT) :: any
 end
 
-local function decodeModQ(s)
-	s = type(s) == "table" and { table.unpack(s, 1, 21) } or { string.byte(tostring(s), 1, 21) }
-	local result = decodeInt(s)
+local function decodeModQ(s: any): BigInt
+	s = type(s) == "table" and { table.unpack(s :: { number }, 1, 21) } or { string.byte(tostring(s), 1, 21) }
+	local result: BigInt = decodeInt(s)
 	result[7] %= q[7]
 
-	return setmetatable(result, modQMT)
+	return setmetatable(result, modQMT) :: any
 end
 
-local function randomModQ()
+local function randomModQ(): BigInt
 	while true do
-		local s = { table.unpack(random.random(), 1, 21) }
-		local result = decodeInt(s)
+		local s: { number } = { table.unpack(random.random() :: any, 1, 21) }
+		local result: BigInt = decodeInt(s)
 		if result[7] < q[7] then
-			return setmetatable(result, modQMT)
+			return setmetatable(result, modQMT) :: any
 		end
 	end
 end
 
-local function hashModQ(data)
+local function hashModQ(data: any): BigInt
 	return decodeModQ(sha256.digest(data))
 end
 
 modQMT = {
 	__index = {
-		encode = function(self)
+		encode = function(self: BigInt): { number }
 			return encodeModQ(self)
 		end,
 	},
 
-	__tostring = function(self)
-		return self:encode():toHex()
+	__tostring = function(self: BigInt): string
+		return (self :: any):encode():toHex()
 	end,
 
-	__add = function(self, other)
+	__add = function(self: any, other: any): BigInt
 		if type(self) == "number" then
 			return other + self
 		end
@@ -227,7 +229,7 @@ modQMT = {
 		return addModQ(self, other)
 	end,
 
-	__sub = function(a, b)
+	__sub = function(a: any, b: any): BigInt
 		if type(a) == "number" then
 			assert(a < 16777216, "number operand too big")
 			a = montgomeryModQ({ a, 0, 0, 0, 0, 0, 0 })
@@ -241,15 +243,15 @@ modQMT = {
 		return subModQ(a, b)
 	end,
 
-	__unm = function(self)
+	__unm = function(self: BigInt): BigInt
 		return subModQ(q, self)
 	end,
 
-	__eq = function(self, other)
+	__eq = function(self: BigInt, other: BigInt): boolean
 		return isEqual(self, other)
 	end,
 
-	__mul = function(self, other)
+	__mul = function(self: any, other: any): BigInt
 		if type(self) == "number" then
 			return other * self
 		end
@@ -268,7 +270,7 @@ modQMT = {
 		return multModQ(self, other)
 	end,
 
-	__div = function(a, b)
+	__div = function(a: any, b: any): BigInt
 		if type(a) == "number" then
 			assert(a < 16777216, "number operand too big")
 			a = montgomeryModQ({ a, 0, 0, 0, 0, 0, 0 })
@@ -279,12 +281,12 @@ modQMT = {
 			b = montgomeryModQ({ b, 0, 0, 0, 0, 0, 0 })
 		end
 
-		local bInv = expModQ(b, qMinusTwoBinary)
+		local bInv: BigInt = expModQ(b, qMinusTwoBinary)
 
 		return multModQ(a, bInv)
 	end,
 
-	__pow = function(self, other)
+	__pow = function(self: BigInt, other: number): BigInt
 		return intExpModQ(self, other)
 	end,
 }

package/src/Shared/EllipticCurveCryptography/random.lua

@@ -1,15 +1,16 @@
---!nonstrict
+--!strict
 --!native
 
 -- random.lua - Random Byte Generator
 local sha256 = require(script.Parent.sha256)
 
-local entropy = ""
-local accumulator, accumulator_len = {}, 0
+local entropy: string = ""
+local accumulator: { string } = {}
+local accumulator_len: number = 0
 
 local random = {}
 
-local function feed(data)
+local function feed(data: any)
 	accumulator_len += 1
 	accumulator[accumulator_len] = tostring(data or "")
 end
@@ -21,7 +22,7 @@ local function digest()
 	accumulator_len = 0
 end
 
-local entropyInitialized = false
+local entropyInitialized: boolean = false
 
 -- Defer this initialization until requested
 local function ensureEntropyInit()
@@ -55,7 +56,7 @@ local function ensureEntropyInit()
 	-- TODO: Suppress this warning
 	warn(
 		string.format(
-			"[EllipticCurveCryptography.random] - Generating entropy took %s ms",
+			"[EllipticCurveCryptography.random] - Generating entropy took %g ms",
 			1000 * (os.clock() - startTime)
 		)
 	)
@@ -72,7 +73,7 @@ function random.save()
 	entropy = tostring(sha256.digest(entropy))
 end
 
-function random.seed(data)
+function random.seed(data: any)
 	ensureEntropyInit()
 
 	feed("seed")
@@ -83,7 +84,7 @@ function random.seed(data)
 	random.save()
 end
 
-function random.random()
+function random.random(): any
 	ensureEntropyInit()
 
 	feed("random")

package/src/Shared/EllipticCurveCryptography/sha256.lua

@@ -1,4 +1,4 @@
---!nonstrict
+--!strict
 --!native
 
 -- SHA-256, HMAC and PBKDF2 functions in ComputerCraft
@@ -10,22 +10,24 @@
 -- Last update: October 10, 2017
 -- Updated by Quenty December 4th, 2023
 
-local twoPower = require(script.Parent.twoPower)
+local twoPower: { [number]: number } = require(script.Parent.twoPower) :: any
 local util = require(script.Parent.util)
 
+type ByteTable = typeof(setmetatable({} :: { number }, {} :: typeof(util.byteTableMT)))
+
 local mod32 = 2 ^ 32
 local band = bit32.band
 local bnot = bit32.bnot
 local bxor = bit32.bxor
 local blshift = bit32.lshift
 
-local function rrotate(n, b)
+local function rrotate(n: number, b: number): number
 	local s = n / twoPower[b]
 	local f = s % 1
 	return (s - f) + f * mod32
 end
 
-local function brshift(int, by) -- Thanks bit32 for bad rshift
+local function brshift(int: number, by: number): number -- Thanks bit32 for bad rshift
 	return math.floor(int / twoPower[by])
 end
 
@@ -107,7 +109,7 @@ local K = {
 	0xc67178f2,
 }
 
-local function counter(incr)
+local function counter(incr: number): (number, number)
 	local t1, t2 = 0, 0
 	if 0xFFFFFFFF - t1 < incr then
 		t2 = t2 + 1
@@ -119,11 +121,11 @@ local function counter(incr)
 	return t2, t1
 end
 
-local function BE_toInt(bs, i)
+local function BE_toInt(bs: { number }, i: number): number
 	return blshift((bs[i] or 0), 24) + blshift((bs[i + 1] or 0), 16) + blshift((bs[i + 2] or 0), 8) + (bs[i + 3] or 0)
 end
 
-local function preprocess(data)
+local function preprocess(data: { number }): { { number } }
 	local len = #data
 	local data_len = #data + 1
 
@@ -135,9 +137,9 @@ local function preprocess(data)
 
 	local blocks = math.ceil(data_len / 64)
 
-	local proc = table.create(blocks)
+	local proc: { { number } } = table.create(blocks)
 	for i = 1, blocks do
-		local block = table.create(16)
+		local block: { number } = table.create(16)
 		proc[i] = block
 		for j = 1, 16 do
 			block[j] = BE_toInt(data, 1 + ((i - 1) * 64) + ((j - 1) * 4))
@@ -148,7 +150,7 @@ local function preprocess(data)
 	return proc
 end
 
-local function digestblock(w, C)
+local function digestblock(w: { number }, C: { number }): { number }
 	for j = 17, 64 do
 		local s0 = bxor(bxor(rrotate(w[j - 15], 7), rrotate(w[j - 15], 18)), brshift(w[j - 15], 3))
 		local s1 = bxor(bxor(rrotate(w[j - 2], 17), rrotate(w[j - 2], 19)), brshift(w[j - 2], 10))
@@ -177,8 +179,8 @@ local function digestblock(w, C)
 	return C
 end
 
-local function toBytes(t, n)
-	local b = table.create(n * 4)
+local function toBytes(t: { number }, n: number): ByteTable
+	local b: { number } = table.create(n * 4)
 	for i = 1, n do
 		b[(i - 1) * 4 + 1] = band(brshift(t[i], 24), 0xFF)
 		b[(i - 1) * 4 + 2] = band(brshift(t[i], 16), 0xFF)
@@ -189,29 +191,36 @@ local function toBytes(t, n)
 	return setmetatable(b, util.byteTableMT)
 end
 
-local function digest(data)
-	data = data or ""
-	data = type(data) == "table" and { table.unpack(data) } or util.stringToByteArray(data)
+local function digest(data: (string | { number })?): ByteTable
+	local rawData: string | { number } = data or ""
+	local byteData: { number }
+	if type(rawData) == "table" then
+		byteData = { table.unpack(rawData) }
+	else
+		byteData = util.stringToByteArray(rawData)
+	end
 
-	data = preprocess(data)
-	local C = { table.unpack(H) }
-	for _, value in ipairs(data) do
+	local proc = preprocess(byteData)
+	local C: { number } = { table.unpack(H) }
+	for _, value in ipairs(proc) do
 		C = digestblock(value, C)
 	end
 
 	return toBytes(C, 8)
 end
 
-local function hmac(data, key)
-	local actualData = type(data) == "table" and { table.unpack(data) } or util.stringToByteArray(data)
-	local actualKey = type(key) == "table" and { table.unpack(key) } or util.stringToByteArray(key)
+local function hmac(data: string | { number }, key: string | { number }): ByteTable
+	local actualData: { number } = type(data) == "table" and { table.unpack(data :: { number }) }
+		or util.stringToByteArray(data :: string)
+	local actualKey: { number } = type(key) == "table" and { table.unpack(key :: { number }) }
+		or util.stringToByteArray(key :: string)
 
 	local blocksize = 64
 
-	actualKey = #actualKey > blocksize and digest(actualKey) or actualKey
+	actualKey = #actualKey > blocksize and (digest(actualKey) :: any) or actualKey
 
-	local ipad = table.create(blocksize)
-	local opad = table.create(blocksize)
+	local ipad: { number } = table.create(blocksize)
+	local opad: { number } = table.create(blocksize)
 
 	for i = 1, blocksize do
 		ipad[i] = bxor(0x36, actualKey[i] or 0)
@@ -222,26 +231,27 @@ local function hmac(data, key)
 		ipad[blocksize + i] = value
 	end
 
-	ipad = digest(ipad)
-	local padded_key = table.create(blocksize * 2)
+	local ipadDigest = digest(ipad)
+	local padded_key: { number } = table.create(blocksize * 2)
 	for i = 1, blocksize do
 		padded_key[i] = opad[i]
-		padded_key[blocksize + i] = ipad[i]
+		padded_key[blocksize + i] = ipadDigest[i]
 	end
 
 	return digest(padded_key)
 end
 
-local function pbkdf2(pass, salt, iter, dklen)
-	local actualSalt = type(salt) == "table" and salt or util.stringToByteArray(salt)
+local function pbkdf2(pass: string | { number }, salt: string | { number }, iter: number, dklen: number?): ByteTable
+	local actualSalt: { number } = type(salt) == "table" and salt :: { number }
+		or util.stringToByteArray(salt :: string)
 	local hashlen = 32
 	local actualDklen = dklen or 32
 	local block = 1
-	local out = {}
+	local out: { number } = {}
 
 	while actualDklen > 0 do
-		local ikey = {}
-		local isalt = { table.unpack(actualSalt) }
+		local ikey: { number } = {}
+		local isalt: { number } = { table.unpack(actualSalt) }
 		local isalt_len = #isalt
 		local clen = actualDklen > hashlen and hashlen or actualDklen
 
@@ -253,7 +263,7 @@ local function pbkdf2(pass, salt, iter, dklen)
 		isalt_len += 4
 
 		for _ = 1, iter do
-			isalt = hmac(isalt, pass)
+			isalt = hmac(isalt, pass) :: any
 			for k = 1, clen do
 				ikey[k] = bxor(isalt[k], ikey[k] or 0)
 			end

package/src/Shared/EllipticCurveCryptography/twoPower.lua

@@ -1,11 +1,11 @@
---!nonstrict
-local twoPower = setmetatable({}, {
-	__index = function(self, index)
+--!strict
+local twoPower: { [number]: number } = setmetatable({}, {
+	__index = function(self: { [number]: number }, index: number): number
 		local value = 2 ^ index
 		self[index] = value
 		return value
 	end,
-})
+}) :: any
 
 -- NOTE: This takes somewhere between 1.5 ms to 4 ms
 -- precache

package/src/Shared/{EllipticCurveCryptography/testing.spec.lua → EllipticCurveCryptography.spec.lua}

@@ -1,10 +1,8 @@
 --!nonstrict
-local require = (require :: any)(
-		game:GetService("ServerScriptService"):FindFirstChild("LoaderUtils", true).Parent
-	).bootstrapStory(script) :: typeof(require(script.Parent.loader).load(script))
+local require = require(script.Parent.loader).load(script)
 
 local Jest = require("Jest")
-local ecc = require(script.Parent)
+local ecc = require("EllipticCurveCryptography")
 
 local describe = Jest.Globals.describe
 local expect = Jest.Globals.expect

package/src/Shared/{EllipticCurveCryptography/benchmark.spec.lua → EllipticCurveCryptographyBenchmark.spec.lua}

@@ -1,10 +1,8 @@
 --!nonstrict
-local require = (require :: any)(
-		game:GetService("ServerScriptService"):FindFirstChild("LoaderUtils", true).Parent
-	).bootstrapStory(script) :: typeof(require(script.Parent.loader).load(script))
+local require = require(script.Parent.loader).load(script)
 
 local Jest = require("Jest")
-local ecc = require(script.Parent)
+local ecc = require("EllipticCurveCryptography")
 
 local describe = Jest.Globals.describe
 local expect = Jest.Globals.expect