333 lines
10 KiB
Lua
333 lines
10 KiB
Lua
require("tests")
|
|
local crypto = require("crypto")
|
|
|
|
-- Test data
|
|
local test_data = "Hello, World!"
|
|
local test_key = "secret-key-123"
|
|
|
|
-- ======================================================================
|
|
-- ENCODING/DECODING TESTS
|
|
-- ======================================================================
|
|
|
|
test("Base64 Encoding/Decoding", function()
|
|
local encoded = crypto.base64_encode(test_data)
|
|
assert_equal(type(encoded), "string")
|
|
assert(#encoded > 0, "encoded string should not be empty")
|
|
|
|
local decoded = crypto.base64_decode(encoded)
|
|
assert_equal(decoded, test_data)
|
|
end)
|
|
|
|
test("Base64 URL Encoding/Decoding", function()
|
|
local encoded = crypto.base64_url_encode(test_data)
|
|
assert_equal(type(encoded), "string")
|
|
|
|
local decoded = crypto.base64_url_decode(encoded)
|
|
assert_equal(decoded, test_data)
|
|
end)
|
|
|
|
test("Hex Encoding/Decoding", function()
|
|
local encoded = crypto.hex_encode(test_data)
|
|
assert_equal(type(encoded), "string")
|
|
assert(encoded:match("^[0-9a-f]+$"), "hex should only contain hex characters")
|
|
|
|
local decoded = crypto.hex_decode(encoded)
|
|
assert_equal(decoded, test_data)
|
|
end)
|
|
|
|
test("Encoding Chain", function()
|
|
local chain_encoded = crypto.encode_chain(test_data, {"hex", "base64"})
|
|
local chain_decoded = crypto.decode_chain(chain_encoded, {"hex", "base64"})
|
|
assert_equal(chain_decoded, test_data)
|
|
end)
|
|
|
|
-- ======================================================================
|
|
-- HASHING TESTS
|
|
-- ======================================================================
|
|
|
|
test("MD5 Hash", function()
|
|
local hash = crypto.md5(test_data)
|
|
assert_equal(type(hash), "string")
|
|
assert_equal(#hash, 32) -- MD5 is 32 hex characters
|
|
assert(hash:match("^[0-9a-f]+$"), "hash should be hex")
|
|
|
|
-- Same input should produce same hash
|
|
assert_equal(crypto.md5(test_data), hash)
|
|
end)
|
|
|
|
test("SHA1 Hash", function()
|
|
local hash = crypto.sha1(test_data)
|
|
assert_equal(type(hash), "string")
|
|
assert_equal(#hash, 40) -- SHA1 is 40 hex characters
|
|
assert(hash:match("^[0-9a-f]+$"), "hash should be hex")
|
|
end)
|
|
|
|
test("SHA256 Hash", function()
|
|
local hash = crypto.sha256(test_data)
|
|
assert_equal(type(hash), "string")
|
|
assert_equal(#hash, 64) -- SHA256 is 64 hex characters
|
|
assert(hash:match("^[0-9a-f]+$"), "hash should be hex")
|
|
end)
|
|
|
|
test("SHA512 Hash", function()
|
|
local hash = crypto.sha512(test_data)
|
|
assert_equal(type(hash), "string")
|
|
assert_equal(#hash, 128) -- SHA512 is 128 hex characters
|
|
assert(hash:match("^[0-9a-f]+$"), "hash should be hex")
|
|
end)
|
|
|
|
test("Hash Multiple Inputs", function()
|
|
local hash1 = crypto.hash_multiple({"hello", "world"})
|
|
local hash2 = crypto.hash_multiple({"hello", "world"})
|
|
local hash3 = crypto.hash_multiple({"world", "hello"})
|
|
|
|
assert_equal(hash1, hash2)
|
|
assert(hash1 ~= hash3, "different order should produce different hash")
|
|
end)
|
|
|
|
-- ======================================================================
|
|
-- HMAC TESTS
|
|
-- ======================================================================
|
|
|
|
test("HMAC SHA1", function()
|
|
local hmac = crypto.hmac_sha1(test_data, test_key)
|
|
assert_equal(type(hmac), "string")
|
|
assert_equal(#hmac, 40) -- SHA1 HMAC is 40 hex characters
|
|
assert(hmac:match("^[0-9a-f]+$"), "hmac should be hex")
|
|
end)
|
|
|
|
test("HMAC SHA256", function()
|
|
local hmac = crypto.hmac_sha256(test_data, test_key)
|
|
assert_equal(type(hmac), "string")
|
|
assert_equal(#hmac, 64) -- SHA256 HMAC is 64 hex characters
|
|
assert(hmac:match("^[0-9a-f]+$"), "hmac should be hex")
|
|
end)
|
|
|
|
test("MAC Functions", function()
|
|
local mac = crypto.mac(test_data, test_key)
|
|
assert_equal(type(mac), "string")
|
|
assert(#mac > 0, "mac should not be empty")
|
|
|
|
local valid = crypto.verify_mac(test_data, test_key, mac)
|
|
assert_equal(valid, true)
|
|
|
|
local invalid = crypto.verify_mac("different data", test_key, mac)
|
|
assert_equal(invalid, false)
|
|
end)
|
|
|
|
-- ======================================================================
|
|
-- UUID TESTS
|
|
-- ======================================================================
|
|
|
|
test("UUID Generation", function()
|
|
local uuid1 = crypto.uuid()
|
|
local uuid2 = crypto.uuid_v4()
|
|
|
|
assert_equal(type(uuid1), "string")
|
|
assert_equal(type(uuid2), "string")
|
|
assert_equal(#uuid1, 36) -- Standard UUID length
|
|
assert_equal(#uuid2, 36)
|
|
assert(uuid1 ~= uuid2, "UUIDs should be unique")
|
|
|
|
assert_equal(crypto.is_uuid(uuid1), true)
|
|
assert_equal(crypto.is_uuid(uuid2), true)
|
|
assert_equal(crypto.is_uuid("not-a-uuid"), false)
|
|
end)
|
|
|
|
-- ======================================================================
|
|
-- RANDOM GENERATION TESTS
|
|
-- ======================================================================
|
|
|
|
test("Random Bytes", function()
|
|
local bytes1 = crypto.random_bytes(16)
|
|
local bytes2 = crypto.random_bytes(16)
|
|
|
|
assert_equal(type(bytes1), "string")
|
|
assert_equal(#bytes1, 16)
|
|
assert(bytes1 ~= bytes2, "random bytes should be different")
|
|
end)
|
|
|
|
test("Random Hex", function()
|
|
local hex1 = crypto.random_hex(8)
|
|
local hex2 = crypto.random_hex(8)
|
|
|
|
assert_equal(type(hex1), "string")
|
|
assert_equal(#hex1, 16) -- 8 bytes = 16 hex characters
|
|
assert(hex1:match("^[0-9a-f]+$"), "should be hex")
|
|
assert(hex1 ~= hex2, "random hex should be different")
|
|
end)
|
|
|
|
test("Random String", function()
|
|
local str1 = crypto.random_string(10)
|
|
local str2 = crypto.random_string(10)
|
|
|
|
assert_equal(type(str1), "string")
|
|
assert_equal(#str1, 10)
|
|
assert(str1 ~= str2, "random strings should be different")
|
|
|
|
local custom = crypto.random_string(5, "abc")
|
|
assert_equal(#custom, 5)
|
|
assert(custom:match("^[abc]+$"), "should only contain specified characters")
|
|
end)
|
|
|
|
test("Random Alphanumeric", function()
|
|
local str = crypto.random_alphanumeric(20)
|
|
assert_equal(#str, 20)
|
|
assert(str:match("^[a-zA-Z0-9]+$"), "should be alphanumeric")
|
|
end)
|
|
|
|
test("Random Password", function()
|
|
local pass1 = crypto.random_password(12)
|
|
local pass2 = crypto.random_password(12, true) -- with symbols
|
|
|
|
assert_equal(#pass1, 12)
|
|
assert_equal(#pass2, 12)
|
|
assert(pass1 ~= pass2, "passwords should be different")
|
|
end)
|
|
|
|
test("Token Generation", function()
|
|
local token1 = crypto.token(32)
|
|
local token2 = crypto.token(32)
|
|
|
|
assert_equal(#token1, 64) -- 32 bytes = 64 hex characters
|
|
assert(token1:match("^[0-9a-f]+$"), "token should be hex")
|
|
assert(token1 ~= token2, "tokens should be unique")
|
|
end)
|
|
|
|
test("Nonce Generation", function()
|
|
local nonce1 = crypto.nonce()
|
|
local nonce2 = crypto.nonce(32)
|
|
|
|
assert_equal(#nonce1, 32) -- default 16 bytes = 32 hex
|
|
assert_equal(#nonce2, 64) -- 32 bytes = 64 hex
|
|
assert(nonce1 ~= nonce2, "nonces should be unique")
|
|
end)
|
|
|
|
-- ======================================================================
|
|
-- UTILITY TESTS
|
|
-- ======================================================================
|
|
|
|
test("Secure Compare", function()
|
|
local str1 = "hello"
|
|
local str2 = "hello"
|
|
local str3 = "world"
|
|
|
|
assert_equal(crypto.secure_compare(str1, str2), true)
|
|
assert_equal(crypto.secure_compare(str1, str3), false)
|
|
end)
|
|
|
|
test("Checksum Functions", function()
|
|
local checksum = crypto.checksum(test_data)
|
|
assert_equal(type(checksum), "string")
|
|
|
|
local valid = crypto.verify_checksum(test_data, checksum)
|
|
assert_equal(valid, true)
|
|
|
|
local invalid = crypto.verify_checksum("different", checksum)
|
|
assert_equal(invalid, false)
|
|
end)
|
|
|
|
test("XOR Encryption", function()
|
|
local key = "mykey"
|
|
local encrypted = crypto.xor_encrypt(test_data, key)
|
|
local decrypted = crypto.xor_decrypt(encrypted, key)
|
|
|
|
assert_equal(decrypted, test_data)
|
|
assert(encrypted ~= test_data, "encrypted should be different")
|
|
end)
|
|
|
|
test("Hash Chain", function()
|
|
local chain1 = crypto.hash_chain(test_data, 100)
|
|
local chain2 = crypto.hash_chain(test_data, 100)
|
|
local chain3 = crypto.hash_chain(test_data, 101)
|
|
|
|
assert_equal(chain1, chain2)
|
|
assert(chain1 ~= chain3, "different iterations should produce different results")
|
|
end)
|
|
|
|
test("Key Derivation", function()
|
|
local derived1, salt1 = crypto.derive_key("password", "salt", 1000)
|
|
local derived2, salt2 = crypto.derive_key("password", salt1, 1000)
|
|
|
|
assert_equal(derived1, derived2)
|
|
assert_equal(salt1, salt2)
|
|
assert_equal(type(derived1), "string")
|
|
assert(#derived1 > 0, "derived key should not be empty")
|
|
end)
|
|
|
|
test("Fingerprint", function()
|
|
local data = {name = "test", value = 42}
|
|
local fp1 = crypto.fingerprint(data)
|
|
local fp2 = crypto.fingerprint(data)
|
|
|
|
assert_equal(fp1, fp2)
|
|
assert_equal(type(fp1), "string")
|
|
assert(#fp1 > 0, "fingerprint should not be empty")
|
|
end)
|
|
|
|
test("Integrity Check", function()
|
|
local check = crypto.integrity_check(test_data)
|
|
|
|
assert_equal(check.data, test_data)
|
|
assert_equal(type(check.hash), "string")
|
|
assert_equal(type(check.timestamp), "number")
|
|
assert_equal(type(check.uuid), "string")
|
|
|
|
local valid = crypto.verify_integrity(check)
|
|
assert_equal(valid, true)
|
|
|
|
-- Tamper with data
|
|
check.data = "tampered"
|
|
local invalid = crypto.verify_integrity(check)
|
|
assert_equal(invalid, false)
|
|
end)
|
|
|
|
-- ======================================================================
|
|
-- ERROR HANDLING TESTS
|
|
-- ======================================================================
|
|
|
|
test("Error Handling", function()
|
|
-- Invalid base64
|
|
local success, err = pcall(crypto.base64_decode, "invalid===base64")
|
|
assert_equal(success, false)
|
|
|
|
-- Invalid hex
|
|
local success2, err2 = pcall(crypto.hex_decode, "invalid_hex")
|
|
assert_equal(success2, false)
|
|
|
|
-- Invalid UUID validation (returns boolean, doesn't throw)
|
|
assert_equal(crypto.is_uuid("not-a-uuid"), false)
|
|
assert_equal(crypto.is_uuid(""), false)
|
|
assert_equal(crypto.is_uuid("12345"), false)
|
|
end)
|
|
|
|
-- ======================================================================
|
|
-- PERFORMANCE TESTS
|
|
-- ======================================================================
|
|
|
|
test("Performance Test", function()
|
|
local large_data = string.rep("test data for performance ", 1000)
|
|
|
|
local start = os.clock()
|
|
local hash = crypto.sha256(large_data)
|
|
local hash_time = os.clock() - start
|
|
|
|
start = os.clock()
|
|
local encoded = crypto.base64_encode(large_data)
|
|
local encode_time = os.clock() - start
|
|
|
|
start = os.clock()
|
|
local decoded = crypto.base64_decode(encoded)
|
|
local decode_time = os.clock() - start
|
|
|
|
print(string.format(" SHA256 of %d bytes: %.3fs", #large_data, hash_time))
|
|
print(string.format(" Base64 encode: %.3fs", encode_time))
|
|
print(string.format(" Base64 decode: %.3fs", decode_time))
|
|
|
|
assert_equal(decoded, large_data)
|
|
assert_equal(type(hash), "string")
|
|
end)
|
|
|
|
summary()
|
|
test_exit()
|