@quenty/ellipticcurvecryptography 1.11.0 → 1.13.0

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")