aboutsummaryrefslogtreecommitdiff
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/core/Makefile2
-rw-r--r--tests/core/build.bat2
-rw-r--r--tests/core/crypto/test_core_crypto.odin155
-rw-r--r--tests/core/crypto/test_core_crypto_hash.odin42
-rw-r--r--tests/core/crypto/test_core_crypto_kdf.odin188
-rw-r--r--tests/core/crypto/test_core_crypto_mac.odin20
-rw-r--r--tests/core/crypto/test_core_crypto_sha3_variants.odin441
-rw-r--r--tests/core/crypto/test_crypto_benchmark.odin20
-rw-r--r--tests/vendor/Makefile5
-rw-r--r--tests/vendor/botan-3.dllbin4820480 -> 0 bytes
-rw-r--r--tests/vendor/botan/test_vendor_botan.odin409
-rw-r--r--tests/vendor/build.bat19
12 files changed, 708 insertions, 595 deletions
diff --git a/tests/core/Makefile b/tests/core/Makefile
index 1207eeec5..ecb05d002 100644
--- a/tests/core/Makefile
+++ b/tests/core/Makefile
@@ -45,7 +45,7 @@ hash_test:
$(ODIN) run hash $(COMMON) -o:speed -no-bounds-check -out:test_hash
crypto_test:
- $(ODIN) run crypto $(COMMON) -o:speed -no-bounds-check -out:test_crypto
+ $(ODIN) run crypto $(COMMON) $(COLLECTION) -o:speed -no-bounds-check -out:test_crypto
noise_test:
$(ODIN) run math/noise $(COMMON) -out:test_noise
diff --git a/tests/core/build.bat b/tests/core/build.bat
index d5f528f0c..210760d00 100644
--- a/tests/core/build.bat
+++ b/tests/core/build.bat
@@ -31,7 +31,7 @@ echo ---
echo ---
echo Running core:crypto tests
echo ---
-%PATH_TO_ODIN% run crypto %COMMON% -out:test_crypto.exe || exit /b
+%PATH_TO_ODIN% run crypto %COMMON% %COLLECTION% -out:test_crypto.exe || exit /b
echo ---
echo Running core:encoding tests
diff --git a/tests/core/crypto/test_core_crypto.odin b/tests/core/crypto/test_core_crypto.odin
index 4ca34fc5a..a6d399097 100644
--- a/tests/core/crypto/test_core_crypto.odin
+++ b/tests/core/crypto/test_core_crypto.odin
@@ -15,36 +15,14 @@ package test_core_crypto
import "core:encoding/hex"
import "core:fmt"
import "core:mem"
-import "core:os"
import "core:testing"
import "core:crypto"
import "core:crypto/chacha20"
import "core:crypto/chacha20poly1305"
-
-import "core:crypto/shake"
import "core:crypto/x25519"
-TEST_count := 0
-TEST_fail := 0
-
-when ODIN_TEST {
- expect :: testing.expect
- log :: testing.log
-} else {
- expect :: proc(t: ^testing.T, condition: bool, message: string, loc := #caller_location) {
- TEST_count += 1
- if !condition {
- TEST_fail += 1
- fmt.printf("[%v] %v\n", loc, message)
- return
- }
- }
- log :: proc(t: ^testing.T, v: any, loc := #caller_location) {
- fmt.printf("[%v] ", loc)
- fmt.printf("log: %v\n", v)
- }
-}
+import tc "tests:common"
main :: proc() {
t := testing.T{}
@@ -53,25 +31,23 @@ main :: proc() {
test_hash(&t)
test_mac(&t)
+ test_kdf(&t) // After hash/mac tests because those should pass first.
test_chacha20(&t)
test_chacha20poly1305(&t)
- test_shake(&t)
test_x25519(&t)
+ test_sha3_variants(&t)
bench_crypto(&t)
- fmt.printf("%v/%v tests successful.\n", TEST_count - TEST_fail, TEST_count)
- if TEST_fail > 0 {
- os.exit(1)
- }
+ tc.report(&t)
}
_PLAINTEXT_SUNSCREEN_STR := "Ladies and Gentlemen of the class of '99: If I could offer you only one tip for the future, sunscreen would be it."
@(test)
test_chacha20 :: proc(t: ^testing.T) {
- log(t, "Testing (X)ChaCha20")
+ tc.log(t, "Testing (X)ChaCha20")
// Test cases taken from RFC 8439, and draft-irtf-cfrg-xchacha-03
plaintext := transmute([]byte)(_PLAINTEXT_SUNSCREEN_STR)
@@ -114,7 +90,7 @@ test_chacha20 :: proc(t: ^testing.T) {
chacha20.xor_bytes(&ctx, derived_ciphertext[:], plaintext[:])
derived_ciphertext_str := string(hex.encode(derived_ciphertext[:], context.temp_allocator))
- expect(
+ tc.expect(
t,
derived_ciphertext_str == ciphertext_str,
fmt.tprintf(
@@ -161,7 +137,7 @@ test_chacha20 :: proc(t: ^testing.T) {
chacha20.xor_bytes(&ctx, derived_ciphertext[:], plaintext[:])
derived_ciphertext_str = string(hex.encode(derived_ciphertext[:], context.temp_allocator))
- expect(
+ tc.expect(
t,
derived_ciphertext_str == xciphertext_str,
fmt.tprintf(
@@ -174,7 +150,7 @@ test_chacha20 :: proc(t: ^testing.T) {
@(test)
test_chacha20poly1305 :: proc(t: ^testing.T) {
- log(t, "Testing chacha20poly1205")
+ tc.log(t, "Testing chacha20poly1205")
plaintext := transmute([]byte)(_PLAINTEXT_SUNSCREEN_STR)
@@ -233,7 +209,7 @@ test_chacha20poly1305 :: proc(t: ^testing.T) {
)
derived_ciphertext_str := string(hex.encode(derived_ciphertext[:], context.temp_allocator))
- expect(
+ tc.expect(
t,
derived_ciphertext_str == ciphertext_str,
fmt.tprintf(
@@ -244,7 +220,7 @@ test_chacha20poly1305 :: proc(t: ^testing.T) {
)
derived_tag_str := string(hex.encode(derived_tag[:], context.temp_allocator))
- expect(
+ tc.expect(
t,
derived_tag_str == tag_str,
fmt.tprintf(
@@ -264,8 +240,8 @@ test_chacha20poly1305 :: proc(t: ^testing.T) {
ciphertext[:],
)
derived_plaintext_str := string(derived_plaintext[:])
- expect(t, ok, "Expected true for decrypt(tag, aad, ciphertext)")
- expect(
+ tc.expect(t, ok, "Expected true for decrypt(tag, aad, ciphertext)")
+ tc.expect(
t,
derived_plaintext_str == _PLAINTEXT_SUNSCREEN_STR,
fmt.tprintf(
@@ -284,7 +260,7 @@ test_chacha20poly1305 :: proc(t: ^testing.T) {
aad[:],
derived_ciphertext[:],
)
- expect(t, !ok, "Expected false for decrypt(tag, aad, corrupted_ciphertext)")
+ tc.expect(t, !ok, "Expected false for decrypt(tag, aad, corrupted_ciphertext)")
aad[0] ~= 0xa5
ok = chacha20poly1305.decrypt(
@@ -295,18 +271,12 @@ test_chacha20poly1305 :: proc(t: ^testing.T) {
aad[:],
ciphertext[:],
)
- expect(t, !ok, "Expected false for decrypt(tag, corrupted_aad, ciphertext)")
-}
-
-TestECDH :: struct {
- scalar: string,
- point: string,
- product: string,
+ tc.expect(t, !ok, "Expected false for decrypt(tag, corrupted_aad, ciphertext)")
}
@(test)
test_x25519 :: proc(t: ^testing.T) {
- log(t, "Testing X25519")
+ tc.log(t, "Testing X25519")
// Local copy of this so that the base point doesn't need to be exported.
_BASE_POINT: [32]byte = {
@@ -314,7 +284,11 @@ test_x25519 :: proc(t: ^testing.T) {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
}
- test_vectors := [?]TestECDH {
+ test_vectors := []struct{
+ scalar: string,
+ point: string,
+ product: string,
+ } {
// Test vectors from RFC 7748
{
"a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
@@ -335,7 +309,7 @@ test_x25519 :: proc(t: ^testing.T) {
x25519.scalarmult(derived_point[:], scalar[:], point[:])
derived_point_str := string(hex.encode(derived_point[:], context.temp_allocator))
- expect(
+ tc.expect(
t,
derived_point_str == v.product,
fmt.tprintf(
@@ -353,7 +327,7 @@ test_x25519 :: proc(t: ^testing.T) {
x25519.scalarmult(p2[:], scalar[:], _BASE_POINT[:])
p1_str := string(hex.encode(p1[:], context.temp_allocator))
p2_str := string(hex.encode(p2[:], context.temp_allocator))
- expect(
+ tc.expect(
t,
p1_str == p2_str,
fmt.tprintf(
@@ -371,16 +345,14 @@ test_x25519 :: proc(t: ^testing.T) {
@(test)
test_rand_bytes :: proc(t: ^testing.T) {
- log(t, "Testing rand_bytes")
+ tc.log(t, "Testing rand_bytes")
if ODIN_OS != .Linux {
- log(t, "rand_bytes not supported - skipping")
+ tc.log(t, "rand_bytes not supported - skipping")
return
}
- allocator := context.allocator
-
- buf := make([]byte, 1 << 25, allocator)
+ buf := make([]byte, 1 << 25, context.allocator)
defer delete(buf)
// Testing a CSPRNG for correctness is incredibly involved and
@@ -405,84 +377,9 @@ test_rand_bytes :: proc(t: ^testing.T) {
}
}
- expect(
+ tc.expect(
t,
seems_ok,
"Expected to randomize the head and tail of the buffer within a handful of attempts",
)
}
-
-TestXOF :: struct {
- sec_strength: int,
- output: string,
- str: string,
-}
-
-@(test)
-test_shake :: proc(t: ^testing.T) {
- test_vectors := [?]TestXOF {
- // SHAKE128
- {
- 128,
- "7f9c2ba4e88f827d616045507605853e",
- "",
- },
- {
- 128,
- "f4202e3c5852f9182a0430fd8144f0a7",
- "The quick brown fox jumps over the lazy dog",
- },
- {
- 128,
- "853f4538be0db9621a6cea659a06c110",
- "The quick brown fox jumps over the lazy dof",
- },
-
- // SHAKE256
- {
- 256,
- "46b9dd2b0ba88d13233b3feb743eeb243fcd52ea62b81b82b50c27646ed5762f",
- "",
- },
- {
- 256,
- "2f671343d9b2e1604dc9dcf0753e5fe15c7c64a0d283cbbf722d411a0e36f6ca",
- "The quick brown fox jumps over the lazy dog",
- },
- {
- 256,
- "46b1ebb2e142c38b9ac9081bef72877fe4723959640fa57119b366ce6899d401",
- "The quick brown fox jumps over the lazy dof",
- },
- }
- for v in test_vectors {
- dst := make([]byte, len(v.output)/2, context.temp_allocator)
-
- data := transmute([]byte)(v.str)
-
- ctx: shake.Context
- switch v.sec_strength {
- case 128:
- shake.init_128(&ctx)
- case 256:
- shake.init_256(&ctx)
- }
-
- shake.write(&ctx, data)
- shake.read(&ctx, dst)
-
- dst_str := string(hex.encode(dst, context.temp_allocator))
-
- expect(
- t,
- dst_str == v.output,
- fmt.tprintf(
- "SHAKE%d: Expected: %s for input of %s, but got %s instead",
- v.sec_strength,
- v.output,
- v.str,
- dst_str,
- ),
- )
- }
-}
diff --git a/tests/core/crypto/test_core_crypto_hash.odin b/tests/core/crypto/test_core_crypto_hash.odin
index 7dc559681..bd40a9b23 100644
--- a/tests/core/crypto/test_core_crypto_hash.odin
+++ b/tests/core/crypto/test_core_crypto_hash.odin
@@ -8,22 +8,22 @@ import "core:testing"
import "core:crypto/hash"
-TestHash :: struct {
- algo: hash.Algorithm,
- hash: string,
- str: string,
-}
+import tc "tests:common"
@(test)
test_hash :: proc(t: ^testing.T) {
- log(t, "Testing Hashes")
+ tc.log(t, "Testing Hashes")
// TODO:
// - Stick the test vectors in a JSON file or something.
data_1_000_000_a := strings.repeat("a", 1_000_000)
- digest: [64]byte // 512-bits is enough for every digest for now.
- test_vectors := [?]TestHash {
+ digest: [hash.MAX_DIGEST_SIZE]byte
+ test_vectors := []struct{
+ algo: hash.Algorithm,
+ hash: string,
+ str: string,
+ } {
// BLAKE2b
{
hash.Algorithm.BLAKE2B,
@@ -424,9 +424,9 @@ test_hash :: proc(t: ^testing.T) {
// MD5 (Insecure)
// - https://datatracker.ietf.org/doc/html/rfc1321
- TestHash{hash.Algorithm.Insecure_MD5, "d41d8cd98f00b204e9800998ecf8427e", ""},
- TestHash{hash.Algorithm.Insecure_MD5, "0cc175b9c0f1b6a831c399e269772661", "a"},
- TestHash{hash.Algorithm.Insecure_MD5, "900150983cd24fb0d6963f7d28e17f72", "abc"},
+ {hash.Algorithm.Insecure_MD5, "d41d8cd98f00b204e9800998ecf8427e", ""},
+ {hash.Algorithm.Insecure_MD5, "0cc175b9c0f1b6a831c399e269772661", "a"},
+ {hash.Algorithm.Insecure_MD5, "900150983cd24fb0d6963f7d28e17f72", "abc"},
{
hash.Algorithm.Insecure_MD5,
"f96b697d7cb7938d525a2f31aaf161d0",
@@ -451,8 +451,8 @@ test_hash :: proc(t: ^testing.T) {
// SHA-1 (Insecure)
// - https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/examples/sha_all.pdf
// - https://www.di-mgt.com.au/sha_testvectors.html
- TestHash{hash.Algorithm.Insecure_SHA1, "da39a3ee5e6b4b0d3255bfef95601890afd80709", ""},
- TestHash{hash.Algorithm.Insecure_SHA1, "a9993e364706816aba3e25717850c26c9cd0d89d", "abc"},
+ {hash.Algorithm.Insecure_SHA1, "da39a3ee5e6b4b0d3255bfef95601890afd80709", ""},
+ {hash.Algorithm.Insecure_SHA1, "a9993e364706816aba3e25717850c26c9cd0d89d", "abc"},
{
hash.Algorithm.Insecure_SHA1,
"f9537c23893d2014f365adf8ffe33b8eb0297ed1",
@@ -463,7 +463,7 @@ test_hash :: proc(t: ^testing.T) {
"346fb528a24b48f563cb061470bcfd23740427ad",
"jkijkljklmklmnlmnomnopnopq",
},
- TestHash{hash.Algorithm.Insecure_SHA1, "86f7e437faa5a7fce15d1ddcb9eaeaea377667b8", "a"},
+ {hash.Algorithm.Insecure_SHA1, "86f7e437faa5a7fce15d1ddcb9eaeaea377667b8", "a"},
{
hash.Algorithm.Insecure_SHA1,
"c729c8996ee0a6f74f4f3248e8957edf704fb624",
@@ -493,7 +493,7 @@ test_hash :: proc(t: ^testing.T) {
dst_str := string(hex.encode(dst, context.temp_allocator))
- expect(
+ tc.expect(
t,
dst_str == v.hash,
fmt.tprintf(
@@ -518,7 +518,7 @@ test_hash :: proc(t: ^testing.T) {
// still correct.
digest_sz := hash.DIGEST_SIZES[algo]
block_sz := hash.BLOCK_SIZES[algo]
- expect(
+ tc.expect(
t,
digest_sz <= hash.MAX_DIGEST_SIZE,
fmt.tprintf(
@@ -528,7 +528,7 @@ test_hash :: proc(t: ^testing.T) {
hash.MAX_DIGEST_SIZE,
),
)
- expect(
+ tc.expect(
t,
block_sz <= hash.MAX_BLOCK_SIZE,
fmt.tprintf(
@@ -550,7 +550,7 @@ test_hash :: proc(t: ^testing.T) {
a_str := string(hex.encode(digest_a, context.temp_allocator))
b_str := string(hex.encode(digest_b, context.temp_allocator))
- expect(
+ tc.expect(
t,
a_str == b_str,
fmt.tprintf(
@@ -568,7 +568,7 @@ test_hash :: proc(t: ^testing.T) {
api_algo := hash.algorithm(&ctx)
api_digest_size := hash.digest_size(&ctx)
- expect(
+ tc.expect(
t,
algo == api_algo,
fmt.tprintf(
@@ -578,7 +578,7 @@ test_hash :: proc(t: ^testing.T) {
api_algo,
),
)
- expect(
+ tc.expect(
t,
hash.DIGEST_SIZES[algo] == api_digest_size,
fmt.tprintf(
@@ -601,7 +601,7 @@ test_hash :: proc(t: ^testing.T) {
b_str = string(hex.encode(digest_b, context.temp_allocator))
c_str := string(hex.encode(digest_c, context.temp_allocator))
- expect(
+ tc.expect(
t,
a_str == b_str && b_str == c_str,
fmt.tprintf(
diff --git a/tests/core/crypto/test_core_crypto_kdf.odin b/tests/core/crypto/test_core_crypto_kdf.odin
new file mode 100644
index 000000000..d9e9a8501
--- /dev/null
+++ b/tests/core/crypto/test_core_crypto_kdf.odin
@@ -0,0 +1,188 @@
+package test_core_crypto
+
+import "core:encoding/hex"
+import "core:fmt"
+import "core:testing"
+
+import "core:crypto/hash"
+import "core:crypto/hkdf"
+import "core:crypto/pbkdf2"
+
+import tc "tests:common"
+
+@(test)
+test_kdf :: proc(t: ^testing.T) {
+ tc.log(t, "Testing KDFs")
+
+ test_hkdf(t)
+ test_pbkdf2(t)
+}
+
+@(test)
+test_hkdf :: proc(t: ^testing.T) {
+ tc.log(t, "Testing HKDF")
+
+ tmp: [128]byte // Good enough.
+
+ test_vectors := []struct {
+ algo: hash.Algorithm,
+ ikm: string,
+ salt: string,
+ info: string,
+ okm: string,
+ } {
+ // SHA-256
+ // - https://www.rfc-editor.org/rfc/rfc5869
+ {
+ hash.Algorithm.SHA256,
+ "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b",
+ "000102030405060708090a0b0c",
+ "f0f1f2f3f4f5f6f7f8f9",
+ "3cb25f25faacd57a90434f64d0362f2a2d2d0a90cf1a5a4c5db02d56ecc4c5bf34007208d5b887185865",
+ },
+ {
+ hash.Algorithm.SHA256,
+ "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f",
+ "606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeaf",
+ "b0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff",
+ "b11e398dc80327a1c8e7f78c596a49344f012eda2d4efad8a050cc4c19afa97c59045a99cac7827271cb41c65e590e09da3275600c2f09b8367793a9aca3db71cc30c58179ec3e87c14c01d5c1f3434f1d87",
+ },
+ {
+ hash.Algorithm.SHA256,
+ "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b",
+ "",
+ "",
+ "8da4e775a563c18f715f802a063c5a31b8a11f5c5ee1879ec3454e5f3c738d2d9d201395faa4b61a96c8",
+ },
+ }
+ for v, _ in test_vectors {
+ algo_name := hash.ALGORITHM_NAMES[v.algo]
+ dst := tmp[:len(v.okm) / 2]
+
+ ikm, _ := hex.decode(transmute([]byte)(v.ikm), context.temp_allocator)
+ salt, _ := hex.decode(transmute([]byte)(v.salt), context.temp_allocator)
+ info, _ := hex.decode(transmute([]byte)(v.info), context.temp_allocator)
+
+ hkdf.extract_and_expand(v.algo, salt, ikm, info, dst)
+
+ dst_str := string(hex.encode(dst, context.temp_allocator))
+
+ tc.expect(
+ t,
+ dst_str == v.okm,
+ fmt.tprintf(
+ "HKDF-%s: Expected: %s for input of (%s, %s, %s), but got %s instead",
+ algo_name,
+ v.okm,
+ v.ikm,
+ v.salt,
+ v.info,
+ dst_str,
+ ),
+ )
+ }
+}
+
+@(test)
+test_pbkdf2 :: proc(t: ^testing.T) {
+ tc.log(t, "Testing PBKDF2")
+
+ tmp: [64]byte // 512-bits is enough for every output for now.
+
+ test_vectors := []struct {
+ algo: hash.Algorithm,
+ password: string,
+ salt: string,
+ iterations: u32,
+ dk: string,
+ } {
+ // SHA-1
+ // - https://www.rfc-editor.org/rfc/rfc2898
+ {
+ hash.Algorithm.Insecure_SHA1,
+ "password",
+ "salt",
+ 1,
+ "0c60c80f961f0e71f3a9b524af6012062fe037a6",
+ },
+ {
+ hash.Algorithm.Insecure_SHA1,
+ "password",
+ "salt",
+ 2,
+ "ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957",
+ },
+ {
+ hash.Algorithm.Insecure_SHA1,
+ "password",
+ "salt",
+ 4096,
+ "4b007901b765489abead49d926f721d065a429c1",
+ },
+ // This passes but takes a about 8 seconds on a modern-ish system.
+ //
+ // {
+ // hash.Algorithm.Insecure_SHA1,
+ // "password",
+ // "salt",
+ // 16777216,
+ // "eefe3d61cd4da4e4e9945b3d6ba2158c2634e984",
+ // },
+ {
+ hash.Algorithm.Insecure_SHA1,
+ "passwordPASSWORDpassword",
+ "saltSALTsaltSALTsaltSALTsaltSALTsalt",
+ 4096,
+ "3d2eec4fe41c849b80c8d83662c0e44a8b291a964cf2f07038",
+ },
+ {
+ hash.Algorithm.Insecure_SHA1,
+ "pass\x00word",
+ "sa\x00lt",
+ 4096,
+ "56fa6aa75548099dcc37d7f03425e0c3",
+ },
+
+ // SHA-256
+ // - https://www.rfc-editor.org/rfc/rfc7914
+ {
+ hash.Algorithm.SHA256,
+ "passwd",
+ "salt",
+ 1,
+ "55ac046e56e3089fec1691c22544b605f94185216dde0465e68b9d57c20dacbc49ca9cccf179b645991664b39d77ef317c71b845b1e30bd509112041d3a19783",
+ },
+ {
+ hash.Algorithm.SHA256,
+ "Password",
+ "NaCl",
+ 80000,
+ "4ddcd8f60b98be21830cee5ef22701f9641a4418d04c0414aeff08876b34ab56a1d425a1225833549adb841b51c9b3176a272bdebba1d078478f62b397f33c8d",
+ },
+ }
+ for v, _ in test_vectors {
+ algo_name := hash.ALGORITHM_NAMES[v.algo]
+ dst := tmp[:len(v.dk) / 2]
+
+ password := transmute([]byte)(v.password)
+ salt := transmute([]byte)(v.salt)
+
+ pbkdf2.derive(v.algo, password, salt, v.iterations, dst)
+
+ dst_str := string(hex.encode(dst, context.temp_allocator))
+
+ tc.expect(
+ t,
+ dst_str == v.dk,
+ fmt.tprintf(
+ "HMAC-%s: Expected: %s for input of (%s, %s, %d), but got %s instead",
+ algo_name,
+ v.dk,
+ v.password,
+ v.salt,
+ v.iterations,
+ dst_str,
+ ),
+ )
+ }
+}
diff --git a/tests/core/crypto/test_core_crypto_mac.odin b/tests/core/crypto/test_core_crypto_mac.odin
index c9ee0f0f7..f0e6fa1bf 100644
--- a/tests/core/crypto/test_core_crypto_mac.odin
+++ b/tests/core/crypto/test_core_crypto_mac.odin
@@ -10,9 +10,11 @@ import "core:crypto/hmac"
import "core:crypto/poly1305"
import "core:crypto/siphash"
+import tc "tests:common"
+
@(test)
test_mac :: proc(t: ^testing.T) {
- log(t, "Testing MACs")
+ tc.log(t, "Testing MACs")
test_hmac(t)
test_poly1305(t)
@@ -81,7 +83,7 @@ test_hmac :: proc(t: ^testing.T) {
msg_str := string(hex.encode(msg, context.temp_allocator))
dst_str := string(hex.encode(dst[:tag_len], context.temp_allocator))
- expect(
+ tc.expect(
t,
dst_str == expected_str,
fmt.tprintf(
@@ -97,7 +99,7 @@ test_hmac :: proc(t: ^testing.T) {
hmac.sum(algo, dst, msg, key)
oneshot_str := string(hex.encode(dst[:tag_len], context.temp_allocator))
- expect(
+ tc.expect(
t,
oneshot_str == expected_str,
fmt.tprintf(
@@ -114,7 +116,7 @@ test_hmac :: proc(t: ^testing.T) {
@(test)
test_poly1305 :: proc(t: ^testing.T) {
- log(t, "Testing poly1305")
+ tc.log(t, "Testing poly1305")
// Test cases taken from poly1305-donna.
key := [poly1305.KEY_SIZE]byte {
@@ -152,13 +154,13 @@ test_poly1305 :: proc(t: ^testing.T) {
// Verify - oneshot + compare
ok := poly1305.verify(tag[:], msg[:], key[:])
- expect(t, ok, "oneshot verify call failed")
+ tc.expect(t, ok, "oneshot verify call failed")
// Sum - oneshot
derived_tag: [poly1305.TAG_SIZE]byte
poly1305.sum(derived_tag[:], msg[:], key[:])
derived_tag_str := string(hex.encode(derived_tag[:], context.temp_allocator))
- expect(
+ tc.expect(
t,
derived_tag_str == tag_str,
fmt.tprintf("Expected %s for sum(msg, key), but got %s instead", tag_str, derived_tag_str),
@@ -177,7 +179,7 @@ test_poly1305 :: proc(t: ^testing.T) {
}
poly1305.final(&ctx, derived_tag[:])
derived_tag_str = string(hex.encode(derived_tag[:], context.temp_allocator))
- expect(
+ tc.expect(
t,
derived_tag_str == tag_str,
fmt.tprintf(
@@ -190,7 +192,7 @@ test_poly1305 :: proc(t: ^testing.T) {
@(test)
test_siphash_2_4 :: proc(t: ^testing.T) {
- log(t, "Testing SipHash-2-4")
+ tc.log(t, "Testing SipHash-2-4")
// Test vectors from
// https://github.com/veorq/SipHash/blob/master/vectors.h
@@ -227,7 +229,7 @@ test_siphash_2_4 :: proc(t: ^testing.T) {
vector := test_vectors[i]
computed := siphash.sum_2_4(data[:], key[:])
- expect(
+ tc.expect(
t,
computed == vector,
fmt.tprintf(
diff --git a/tests/core/crypto/test_core_crypto_sha3_variants.odin b/tests/core/crypto/test_core_crypto_sha3_variants.odin
new file mode 100644
index 000000000..ec2d24331
--- /dev/null
+++ b/tests/core/crypto/test_core_crypto_sha3_variants.odin
@@ -0,0 +1,441 @@
+package test_core_crypto
+
+import "core:encoding/hex"
+import "core:fmt"
+import "core:testing"
+
+import "core:crypto/kmac"
+import "core:crypto/shake"
+import "core:crypto/tuplehash"
+
+import tc "tests:common"
+
+@(test)
+test_sha3_variants :: proc(t: ^testing.T) {
+ tc.log(t, "Testing SHA3 derived functions")
+
+ test_shake(t)
+ test_cshake(t)
+ test_tuplehash(t)
+ test_kmac(t)
+}
+
+@(test)
+test_shake :: proc(t: ^testing.T) {
+ tc.log(t, "Testing SHAKE")
+
+ test_vectors := []struct {
+ sec_strength: int,
+ output: string,
+ str: string,
+ } {
+ // SHAKE128
+ {128, "7f9c2ba4e88f827d616045507605853e", ""},
+ {128, "f4202e3c5852f9182a0430fd8144f0a7", "The quick brown fox jumps over the lazy dog"},
+ {128, "853f4538be0db9621a6cea659a06c110", "The quick brown fox jumps over the lazy dof"},
+
+ // SHAKE256
+ {256, "46b9dd2b0ba88d13233b3feb743eeb243fcd52ea62b81b82b50c27646ed5762f", ""},
+ {
+ 256,
+ "2f671343d9b2e1604dc9dcf0753e5fe15c7c64a0d283cbbf722d411a0e36f6ca",
+ "The quick brown fox jumps over the lazy dog",
+ },
+ {
+ 256,
+ "46b1ebb2e142c38b9ac9081bef72877fe4723959640fa57119b366ce6899d401",
+ "The quick brown fox jumps over the lazy dof",
+ },
+ }
+
+ for v in test_vectors {
+ dst := make([]byte, len(v.output) / 2, context.temp_allocator)
+
+ ctx: shake.Context
+ switch v.sec_strength {
+ case 128:
+ shake.init_128(&ctx)
+ case 256:
+ shake.init_256(&ctx)
+ }
+
+ shake.write(&ctx, transmute([]byte)(v.str))
+ shake.read(&ctx, dst)
+
+ dst_str := string(hex.encode(dst, context.temp_allocator))
+
+ tc.expect(
+ t,
+ dst_str == v.output,
+ fmt.tprintf(
+ "SHAKE%d: Expected: %s for input of %s, but got %s instead",
+ v.sec_strength,
+ v.output,
+ v.str,
+ dst_str,
+ ),
+ )
+ }
+}
+
+@(test)
+test_cshake :: proc(t: ^testing.T) {
+ tc.log(t, "Testing cSHAKE")
+
+ test_vectors := []struct {
+ sec_strength: int,
+ domainsep: string,
+ output: string,
+ str: string,
+ } {
+ // cSHAKE128
+ // - https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/cSHAKE_samples.pdf
+ {
+ 128,
+ "Email Signature",
+ "c1c36925b6409a04f1b504fcbca9d82b4017277cb5ed2b2065fc1d3814d5aaf5",
+ "00010203",
+ },
+ {
+ 128,
+ "Email Signature",
+ "c5221d50e4f822d96a2e8881a961420f294b7b24fe3d2094baed2c6524cc166b",
+ "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7",
+ },
+
+ // cSHAKE256
+ // - https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/cSHAKE_samples.pdf
+ {
+ 256,
+ "Email Signature",
+ "d008828e2b80ac9d2218ffee1d070c48b8e4c87bff32c9699d5b6896eee0edd164020e2be0560858d9c00c037e34a96937c561a74c412bb4c746469527281c8c",
+ "00010203",
+ },
+ {
+ 256,
+ "Email Signature",
+ "07dc27b11e51fbac75bc7b3c1d983e8b4b85fb1defaf218912ac86430273091727f42b17ed1df63e8ec118f04b23633c1dfb1574c8fb55cb45da8e25afb092bb",
+ "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7",
+ },
+ }
+
+ for v in test_vectors {
+ dst := make([]byte, len(v.output) / 2, context.temp_allocator)
+
+ domainsep := transmute([]byte)(v.domainsep)
+
+ ctx: shake.Context
+ switch v.sec_strength {
+ case 128:
+ shake.init_cshake_128(&ctx, domainsep)
+ case 256:
+ shake.init_cshake_256(&ctx, domainsep)
+ }
+
+ data, _ := hex.decode(transmute([]byte)(v.str))
+ shake.write(&ctx, data)
+ shake.read(&ctx, dst)
+
+ dst_str := string(hex.encode(dst, context.temp_allocator))
+
+ tc.expect(
+ t,
+ dst_str == v.output,
+ fmt.tprintf(
+ "cSHAKE%d: Expected: %s for input of %s, but got %s instead",
+ v.sec_strength,
+ v.output,
+ v.str,
+ dst_str,
+ ),
+ )
+ }
+}
+
+@(test)
+test_tuplehash :: proc(t: ^testing.T) {
+ tc.log(t, "Testing TupleHash(XOF)")
+
+ test_vectors := []struct {
+ sec_strength: int,
+ domainsep: string,
+ output: string,
+ tuple: []string,
+ is_xof: bool,
+ } {
+ // TupleHash128
+ // - https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/TupleHash_samples.pdf
+ {
+ 128,
+ "",
+ "c5d8786c1afb9b82111ab34b65b2c0048fa64e6d48e263264ce1707d3ffc8ed1",
+ []string{
+ "000102",
+ "101112131415",
+ },
+ false,
+ },
+ {
+ 128,
+ "My Tuple App",
+ "75cdb20ff4db1154e841d758e24160c54bae86eb8c13e7f5f40eb35588e96dfb",
+ []string{
+ "000102",
+ "101112131415",
+ },
+ false,
+ },
+ {
+ 128,
+ "My Tuple App",
+ "e60f202c89a2631eda8d4c588ca5fd07f39e5151998deccf973adb3804bb6e84",
+ []string{
+ "000102",
+ "101112131415",
+ "202122232425262728",
+ },
+ false,
+ },
+
+ // TupleHash256
+ // - https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/TupleHash_samples.pdf
+ {
+ 256,
+ "",
+ "cfb7058caca5e668f81a12a20a2195ce97a925f1dba3e7449a56f82201ec607311ac2696b1ab5ea2352df1423bde7bd4bb78c9aed1a853c78672f9eb23bbe194",
+ []string{
+ "000102",
+ "101112131415",
+ },
+ false,
+ },
+ {
+ 256,
+ "My Tuple App",
+ "147c2191d5ed7efd98dbd96d7ab5a11692576f5fe2a5065f3e33de6bba9f3aa1c4e9a068a289c61c95aab30aee1e410b0b607de3620e24a4e3bf9852a1d4367e",
+ []string{
+ "000102",
+ "101112131415",
+ },
+ false,
+ },
+ {
+ 256,
+ "My Tuple App",
+ "45000be63f9b6bfd89f54717670f69a9bc763591a4f05c50d68891a744bcc6e7d6d5b5e82c018da999ed35b0bb49c9678e526abd8e85c13ed254021db9e790ce",
+ []string{
+ "000102",
+ "101112131415",
+ "202122232425262728",
+ },
+ false,
+ },
+
+ // TupleHashXOF128
+ // - https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/TupleHashXOF_samples.pdf
+ {
+ 128,
+ "",
+ "2f103cd7c32320353495c68de1a8129245c6325f6f2a3d608d92179c96e68488",
+ []string{
+ "000102",
+ "101112131415",
+ },
+ true,
+ },
+ {
+ 128,
+ "My Tuple App",
+ "3fc8ad69453128292859a18b6c67d7ad85f01b32815e22ce839c49ec374e9b9a",
+ []string{
+ "000102",
+ "101112131415",
+ },
+ true,
+ },
+ {
+ 128,
+ "My Tuple App",
+ "900fe16cad098d28e74d632ed852f99daab7f7df4d99e775657885b4bf76d6f8",
+ []string{
+ "000102",
+ "101112131415",
+ "202122232425262728",
+ },
+ true,
+ },
+
+ // TupleHashXOF256
+ // - https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/TupleHashXOF_samples.pdf
+ {
+ 256,
+ "",
+ "03ded4610ed6450a1e3f8bc44951d14fbc384ab0efe57b000df6b6df5aae7cd568e77377daf13f37ec75cf5fc598b6841d51dd207c991cd45d210ba60ac52eb9",
+ []string{
+ "000102",
+ "101112131415",
+ },
+ true,
+ },
+ {
+ 256,
+ "My Tuple App",
+ "6483cb3c9952eb20e830af4785851fc597ee3bf93bb7602c0ef6a65d741aeca7e63c3b128981aa05c6d27438c79d2754bb1b7191f125d6620fca12ce658b2442",
+ []string{
+ "000102",
+ "101112131415",
+ },
+ true,
+ },
+ {
+ 256,
+ "My Tuple App",
+ "0c59b11464f2336c34663ed51b2b950bec743610856f36c28d1d088d8a2446284dd09830a6a178dc752376199fae935d86cfdee5913d4922dfd369b66a53c897",
+ []string{
+ "000102",
+ "101112131415",
+ "202122232425262728",
+ },
+ true,
+ },
+ }
+
+ for v in test_vectors {
+ dst := make([]byte, len(v.output) / 2, context.temp_allocator)
+
+ domainsep := transmute([]byte)(v.domainsep)
+
+ ctx: tuplehash.Context
+ switch v.sec_strength {
+ case 128:
+ tuplehash.init_128(&ctx, domainsep)
+ case 256:
+ tuplehash.init_256(&ctx, domainsep)
+ }
+
+ for e in v.tuple {
+ data, _ := hex.decode(transmute([]byte)(e))
+ tuplehash.write_element(&ctx, data)
+ }
+
+ suffix: string
+ switch v.is_xof {
+ case true:
+ suffix = "XOF"
+ tuplehash.read(&ctx, dst)
+ case false:
+ tuplehash.final(&ctx, dst)
+ }
+
+ dst_str := string(hex.encode(dst, context.temp_allocator))
+
+ tc.expect(
+ t,
+ dst_str == v.output,
+ fmt.tprintf(
+ "TupleHash%s%d: Expected: %s for input of %v, but got %s instead",
+ suffix,
+ v.sec_strength,
+ v.output,
+ v.tuple,
+ dst_str,
+ ),
+ )
+ }
+}
+
+@(test)
+test_kmac :: proc(t:^testing.T) {
+ tc.log(t, "Testing KMAC")
+
+ test_vectors := []struct {
+ sec_strength: int,
+ key: string,
+ domainsep: string,
+ msg: string,
+ output: string,
+ } {
+ // KMAC128
+ // - https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/KMAC_samples.pdf
+ {
+ 128,
+ "404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f",
+ "",
+ "00010203",
+ "e5780b0d3ea6f7d3a429c5706aa43a00fadbd7d49628839e3187243f456ee14e",
+ },
+ {
+ 128,
+ "404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f",
+ "My Tagged Application",
+ "00010203",
+ "3b1fba963cd8b0b59e8c1a6d71888b7143651af8ba0a7070c0979e2811324aa5",
+ },
+ {
+ 128,
+ "404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f",
+ "My Tagged Application",
+ "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7",
+ "1f5b4e6cca02209e0dcb5ca635b89a15e271ecc760071dfd805faa38f9729230",
+ },
+
+ // KMAC256
+ // - https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/KMAC_samples.pdf
+ {
+ 256,
+ "404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f",
+ "My Tagged Application",
+ "00010203",
+ "20c570c31346f703c9ac36c61c03cb64c3970d0cfc787e9b79599d273a68d2f7f69d4cc3de9d104a351689f27cf6f5951f0103f33f4f24871024d9c27773a8dd",
+ },
+ {
+ 256,
+ "404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f",
+ "",
+ "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7",
+ "75358cf39e41494e949707927cee0af20a3ff553904c86b08f21cc414bcfd691589d27cf5e15369cbbff8b9a4c2eb17800855d0235ff635da82533ec6b759b69",
+ },
+ {
+ 256,
+ "404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f",
+ "My Tagged Application",
+ "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7",
+ "b58618f71f92e1d56c1b8c55ddd7cd188b97b4ca4d99831eb2699a837da2e4d970fbacfde50033aea585f1a2708510c32d07880801bd182898fe476876fc8965",
+ },
+ }
+
+ for v in test_vectors {
+ dst := make([]byte, len(v.output) / 2, context.temp_allocator)
+
+ key, _ := hex.decode(transmute([]byte)(v.key))
+ domainsep := transmute([]byte)(v.domainsep)
+
+ ctx: kmac.Context
+ switch v.sec_strength {
+ case 128:
+ kmac.init_128(&ctx, key, domainsep)
+ case 256:
+ kmac.init_256(&ctx, key, domainsep)
+ }
+
+ data, _ := hex.decode(transmute([]byte)(v.msg))
+ kmac.update(&ctx, data)
+ kmac.final(&ctx, dst)
+
+ dst_str := string(hex.encode(dst, context.temp_allocator))
+
+ tc.expect(
+ t,
+ dst_str == v.output,
+ fmt.tprintf(
+ "KMAC%d: Expected: %s for input of (%s, %s, %s), but got %s instead",
+ v.sec_strength,
+ v.output,
+ v.key,
+ v.domainsep,
+ v.msg,
+ dst_str,
+ ),
+ )
+ }
+}
diff --git a/tests/core/crypto/test_crypto_benchmark.odin b/tests/core/crypto/test_crypto_benchmark.odin
index cadcf8bec..494913b6b 100644
--- a/tests/core/crypto/test_crypto_benchmark.odin
+++ b/tests/core/crypto/test_crypto_benchmark.odin
@@ -10,6 +10,8 @@ import "core:crypto/chacha20poly1305"
import "core:crypto/poly1305"
import "core:crypto/x25519"
+import tc "tests:common"
+
// Cryptographic primitive benchmarks.
@(test)
@@ -150,19 +152,19 @@ bench_chacha20 :: proc(t: ^testing.T) {
}
err := time.benchmark(options, context.allocator)
- expect(t, err == nil, name)
+ tc.expect(t, err == nil, name)
benchmark_print(name, options)
name = "ChaCha20 1024 bytes"
options.bytes = 1024
err = time.benchmark(options, context.allocator)
- expect(t, err == nil, name)
+ tc.expect(t, err == nil, name)
benchmark_print(name, options)
name = "ChaCha20 65536 bytes"
options.bytes = 65536
err = time.benchmark(options, context.allocator)
- expect(t, err == nil, name)
+ tc.expect(t, err == nil, name)
benchmark_print(name, options)
}
@@ -177,13 +179,13 @@ bench_poly1305 :: proc(t: ^testing.T) {
}
err := time.benchmark(options, context.allocator)
- expect(t, err == nil, name)
+ tc.expect(t, err == nil, name)
benchmark_print(name, options)
name = "Poly1305 1024 zero bytes"
options.bytes = 1024
err = time.benchmark(options, context.allocator)
- expect(t, err == nil, name)
+ tc.expect(t, err == nil, name)
benchmark_print(name, options)
}
@@ -198,19 +200,19 @@ bench_chacha20poly1305 :: proc(t: ^testing.T) {
}
err := time.benchmark(options, context.allocator)
- expect(t, err == nil, name)
+ tc.expect(t, err == nil, name)
benchmark_print(name, options)
name = "chacha20poly1305 1024 bytes"
options.bytes = 1024
err = time.benchmark(options, context.allocator)
- expect(t, err == nil, name)
+ tc.expect(t, err == nil, name)
benchmark_print(name, options)
name = "chacha20poly1305 65536 bytes"
options.bytes = 65536
err = time.benchmark(options, context.allocator)
- expect(t, err == nil, name)
+ tc.expect(t, err == nil, name)
benchmark_print(name, options)
}
@@ -229,7 +231,7 @@ bench_x25519 :: proc(t: ^testing.T) {
}
elapsed := time.since(start)
- log(
+ tc.log(
t,
fmt.tprintf("x25519.scalarmult: ~%f us/op", time.duration_microseconds(elapsed) / iters),
)
diff --git a/tests/vendor/Makefile b/tests/vendor/Makefile
index 6c68d7908..7d6b84978 100644
--- a/tests/vendor/Makefile
+++ b/tests/vendor/Makefile
@@ -7,7 +7,4 @@ ifeq ($(OS), OpenBSD)
ODINFLAGS:=$(ODINFLAGS) -extra-linker-flags:-L/usr/local/lib
endif
-all: botan_test
-
-botan_test:
- $(ODIN) run botan -o:speed -no-bounds-check $(ODINFLAGS) -out=vendor_botan
+all:
diff --git a/tests/vendor/botan-3.dll b/tests/vendor/botan-3.dll
deleted file mode 100644
index d8f04720b..000000000
--- a/tests/vendor/botan-3.dll
+++ /dev/null
Binary files differ
diff --git a/tests/vendor/botan/test_vendor_botan.odin b/tests/vendor/botan/test_vendor_botan.odin
deleted file mode 100644
index 465589407..000000000
--- a/tests/vendor/botan/test_vendor_botan.odin
+++ /dev/null
@@ -1,409 +0,0 @@
-package test_vendor_botan
-
-/*
- Copyright 2021 zhibog
- Made available under the BSD-3 license.
-
- List of contributors:
- zhibog: Initial implementation.
- Jeroen van Rijn: Test runner setup.
-
- Tests for the hashing algorithms within the Botan library.
- Where possible, the official test vectors are used to validate the implementation.
-*/
-
-import "core:testing"
-import "core:fmt"
-import "core:os"
-import "core:strings"
-
-import "vendor:botan/legacy/md5"
-import "vendor:botan/legacy/sha1"
-import "vendor:botan/sha2"
-import "vendor:botan/sha3"
-import "vendor:botan/legacy/keccak"
-import "vendor:botan/shake"
-import "vendor:botan/blake2b"
-import "vendor:botan/sm3"
-import "vendor:botan/siphash"
-
-TEST_count := 0
-TEST_fail := 0
-
-when ODIN_TEST {
- expect :: testing.expect
- log :: testing.log
-} else {
- expect :: proc(t: ^testing.T, condition: bool, message: string, loc := #caller_location) {
- fmt.printf("[%v] ", loc)
- TEST_count += 1
- if !condition {
- TEST_fail += 1
- fmt.println(message)
- return
- }
- fmt.println(" PASS")
- }
- log :: proc(t: ^testing.T, v: any, loc := #caller_location) {
- fmt.printf("[%v] ", loc)
- fmt.printf("log: %v\n", v)
- }
-}
-
-main :: proc() {
- t := testing.T{}
- test_md5(&t)
- test_sha1(&t)
- test_sha224(&t)
- test_sha256(&t)
- test_sha384(&t)
- test_sha512(&t)
- test_sha3_224(&t)
- test_sha3_256(&t)
- test_sha3_384(&t)
- test_sha3_512(&t)
- // test_shake_128(&t)
- // test_shake_256(&t)
- test_keccak_512(&t)
- test_blake2b(&t)
- test_sm3(&t)
- test_siphash_2_4(&t)
-
- fmt.printf("%v/%v tests successful.\n", TEST_count - TEST_fail, TEST_count)
- if TEST_fail > 0 {
- os.exit(1)
- }
-}
-
-TestHash :: struct {
- hash: string,
- str: string,
-}
-
-hex_string :: proc(bytes: []byte, allocator := context.temp_allocator) -> string {
- lut: [16]byte = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}
- buf := make([]byte, len(bytes) * 2, allocator)
- for i := 0; i < len(bytes); i += 1 {
- buf[i * 2 + 0] = lut[bytes[i] >> 4 & 0xf]
- buf[i * 2 + 1] = lut[bytes[i] & 0xf]
- }
- return string(buf)
-}
-
-@(test)
-test_md5 :: proc(t: ^testing.T) {
- // Official test vectors from https://datatracker.ietf.org/doc/html/rfc1321
- test_vectors := [?]TestHash {
- TestHash{"d41d8cd98f00b204e9800998ecf8427e", ""},
- TestHash{"0cc175b9c0f1b6a831c399e269772661", "a"},
- TestHash{"900150983cd24fb0d6963f7d28e17f72", "abc"},
- TestHash{"f96b697d7cb7938d525a2f31aaf161d0", "message digest"},
- TestHash{"c3fcd3d76192e4007dfb496cca67e13b", "abcdefghijklmnopqrstuvwxyz"},
- TestHash{"d174ab98d277d9f5a5611c2c9f419d9f", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"},
- TestHash{"57edf4a22be3c955ac49da2e2107b67a", "12345678901234567890123456789012345678901234567890123456789012345678901234567890"},
- }
- for v, _ in test_vectors {
- computed := md5.hash(v.str)
- computed_str := hex_string(computed[:])
- expect(t, computed_str == v.hash, fmt.tprintf("Expected: %s for input of %s, but got %s instead", v.hash, v.str, computed_str))
- }
-}
-
-@(test)
-test_sha1 :: proc(t: ^testing.T) {
- // Test vectors from
- // https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/examples/sha_all.pdf
- // https://www.di-mgt.com.au/sha_testvectors.html
- test_vectors := [?]TestHash {
- TestHash{"da39a3ee5e6b4b0d3255bfef95601890afd80709", ""},
- TestHash{"a9993e364706816aba3e25717850c26c9cd0d89d", "abc"},
- TestHash{"f9537c23893d2014f365adf8ffe33b8eb0297ed1", "abcdbcdecdefdefgefghfghighijhi"},
- TestHash{"346fb528a24b48f563cb061470bcfd23740427ad", "jkijkljklmklmnlmnomnopnopq"},
- TestHash{"86f7e437faa5a7fce15d1ddcb9eaeaea377667b8", "a"},
- TestHash{"c729c8996ee0a6f74f4f3248e8957edf704fb624", "01234567012345670123456701234567"},
- TestHash{"84983e441c3bd26ebaae4aa1f95129e5e54670f1", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"},
- TestHash{"a49b2446a02c645bf419f995b67091253a04a259", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"},
- }
- for v, _ in test_vectors {
- computed := sha1.hash(v.str)
- computed_str := hex_string(computed[:])
- expect(t, computed_str == v.hash, fmt.tprintf("Expected: %s for input of %s, but got %s instead", v.hash, v.str, computed_str))
- }
-}
-
-@(test)
-test_sha224 :: proc(t: ^testing.T) {
- // Test vectors from
- // https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/examples/sha_all.pdf
- // https://www.di-mgt.com.au/sha_testvectors.html
- // https://datatracker.ietf.org/doc/html/rfc3874#section-3.3
- data_1_000_000_a := strings.repeat("a", 1_000_000)
- test_vectors := [?]TestHash {
- TestHash{"d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f", ""},
- TestHash{"23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7", "abc"},
- TestHash{"75388b16512776cc5dba5da1fd890150b0c6455cb4f58b1952522525", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"},
- TestHash{"c97ca9a559850ce97a04a96def6d99a9e0e0e2ab14e6b8df265fc0b3", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"},
- TestHash{"20794655980c91d8bbb4c1ea97618a4bf03f42581948b2ee4ee7ad67", data_1_000_000_a},
- }
- for v, _ in test_vectors {
- computed := sha2.hash_224(v.str)
- computed_str := hex_string(computed[:])
- expect(t, computed_str == v.hash, fmt.tprintf("Expected: %s for input of %s, but got %s instead", v.hash, v.str, computed_str))
- }
-}
-
-@(test)
-test_sha256 :: proc(t: ^testing.T) {
- // Test vectors from
- // https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/examples/sha_all.pdf
- // https://www.di-mgt.com.au/sha_testvectors.html
- test_vectors := [?]TestHash {
- TestHash{"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", ""},
- TestHash{"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad", "abc"},
- TestHash{"248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"},
- TestHash{"cf5b16a778af8380036ce59e7b0492370b249b11e8f07a51afac45037afee9d1", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"},
- }
- for v, _ in test_vectors {
- computed := sha2.hash_256(v.str)
- computed_str := hex_string(computed[:])
- expect(t, computed_str == v.hash, fmt.tprintf("Expected: %s for input of %s, but got %s instead", v.hash, v.str, computed_str))
- }
-}
-
-@(test)
-test_sha384 :: proc(t: ^testing.T) {
- // Test vectors from
- // https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/examples/sha_all.pdf
- // https://www.di-mgt.com.au/sha_testvectors.html
- test_vectors := [?]TestHash {
- TestHash{"38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b", ""},
- TestHash{"cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7", "abc"},
- TestHash{"3391fdddfc8dc7393707a65b1b4709397cf8b1d162af05abfe8f450de5f36bc6b0455a8520bc4e6f5fe95b1fe3c8452b", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"},
- TestHash{"09330c33f71147e83d192fc782cd1b4753111b173b3b05d22fa08086e3b0f712fcc7c71a557e2db966c3e9fa91746039", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"},
- }
- for v, _ in test_vectors {
- computed := sha2.hash_384(v.str)
- computed_str := hex_string(computed[:])
- expect(t, computed_str == v.hash, fmt.tprintf("Expected: %s for input of %s, but got %s instead", v.hash, v.str, computed_str))
- }
-}
-
-@(test)
-test_sha512 :: proc(t: ^testing.T) {
- // Test vectors from
- // https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/examples/sha_all.pdf
- // https://www.di-mgt.com.au/sha_testvectors.html
- test_vectors := [?]TestHash {
- TestHash{"cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e", ""},
- TestHash{"ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f", "abc"},
- TestHash{"204a8fc6dda82f0a0ced7beb8e08a41657c16ef468b228a8279be331a703c33596fd15c13b1b07f9aa1d3bea57789ca031ad85c7a71dd70354ec631238ca3445", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"},
- TestHash{"8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"},
- }
- for v, _ in test_vectors {
- computed := sha2.hash_512(v.str)
- computed_str := hex_string(computed[:])
- expect(t, computed_str == v.hash, fmt.tprintf("Expected: %s for input of %s, but got %s instead", v.hash, v.str, computed_str))
- }
-}
-
-@(test)
-test_sha3_224 :: proc(t: ^testing.T) {
- // Test vectors from
- // https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/examples/sha_all.pdf
- // https://www.di-mgt.com.au/sha_testvectors.html
- test_vectors := [?]TestHash {
- TestHash{"6b4e03423667dbb73b6e15454f0eb1abd4597f9a1b078e3f5b5a6bc7", ""},
- TestHash{"e642824c3f8cf24ad09234ee7d3c766fc9a3a5168d0c94ad73b46fdf", "abc"},
- TestHash{"10241ac5187380bd501192e4e56b5280908727dd8fe0d10d4e5ad91e", "abcdbcdecdefdefgefghfghighijhi"},
- TestHash{"fd645fe07d814c397e85e85f92fe58b949f55efa4d3468b2468da45a", "jkijkljklmklmnlmnomnopnopq"},
- TestHash{"9e86ff69557ca95f405f081269685b38e3a819b309ee942f482b6a8b", "a"},
- TestHash{"6961f694b2ff3ed6f0c830d2c66da0c5e7ca9445f7c0dca679171112", "01234567012345670123456701234567"},
- TestHash{"8a24108b154ada21c9fd5574494479ba5c7e7ab76ef264ead0fcce33", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"},
- TestHash{"543e6868e1666c1a643630df77367ae5a62a85070a51c14cbf665cbc", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"},
- }
- for v, _ in test_vectors {
- computed := sha3.hash_224(v.str)
- computed_str := hex_string(computed[:])
- expect(t, computed_str == v.hash, fmt.tprintf("Expected: %s for input of %s, but got %s instead", v.hash, v.str, computed_str))
- }
-}
-
-@(test)
-test_sha3_256 :: proc(t: ^testing.T) {
- // Test vectors from
- // https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/examples/sha_all.pdf
- // https://www.di-mgt.com.au/sha_testvectors.html
- test_vectors := [?]TestHash {
- TestHash{"a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a", ""},
- TestHash{"3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532", "abc"},
- TestHash{"565ada1ced21278cfaffdde00dea0107964121ac25e4e978abc59412be74550a", "abcdbcdecdefdefgefghfghighijhi"},
- TestHash{"8cc1709d520f495ce972ece48b0d2e1f74ec80d53bc5c47457142158fae15d98", "jkijkljklmklmnlmnomnopnopq"},
- TestHash{"80084bf2fba02475726feb2cab2d8215eab14bc6bdd8bfb2c8151257032ecd8b", "a"},
- TestHash{"e4786de5f88f7d374b7288f225ea9f2f7654da200bab5d417e1fb52d49202767", "01234567012345670123456701234567"},
- TestHash{"41c0dba2a9d6240849100376a8235e2c82e1b9998a999e21db32dd97496d3376", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"},
- TestHash{"916f6061fe879741ca6469b43971dfdb28b1a32dc36cb3254e812be27aad1d18", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"},
- }
- for v, _ in test_vectors {
- computed := sha3.hash_256(v.str)
- computed_str := hex_string(computed[:])
- expect(t, computed_str == v.hash, fmt.tprintf("Expected: %s for input of %s, but got %s instead", v.hash, v.str, computed_str))
- }
-}
-
-@(test)
-test_sha3_384 :: proc(t: ^testing.T) {
- // Test vectors from
- // https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/examples/sha_all.pdf
- // https://www.di-mgt.com.au/sha_testvectors.html
- test_vectors := [?]TestHash {
- TestHash{"0c63a75b845e4f7d01107d852e4c2485c51a50aaaa94fc61995e71bbee983a2ac3713831264adb47fb6bd1e058d5f004", ""},
- TestHash{"ec01498288516fc926459f58e2c6ad8df9b473cb0fc08c2596da7cf0e49be4b298d88cea927ac7f539f1edf228376d25", "abc"},
- TestHash{"9aa92dbb716ebb573def0d5e3cdd28d6add38ada310b602b8916e690a3257b7144e5ddd3d0dbbc559c48480d34d57a9a", "abcdbcdecdefdefgefghfghighijhi"},
- TestHash{"77c90323d7392bcdee8a3e7f74f19f47b7d1b1a825ac6a2d8d882a72317879cc26597035f1fc24fe65090b125a691282", "jkijkljklmklmnlmnomnopnopq"},
- TestHash{"1815f774f320491b48569efec794d249eeb59aae46d22bf77dafe25c5edc28d7ea44f93ee1234aa88f61c91912a4ccd9", "a"},
- TestHash{"51072590ad4c51b27ff8265590d74f92de7cc55284168e414ca960087c693285b08a283c6b19d77632994cb9eb93f1be", "01234567012345670123456701234567"},
- TestHash{"991c665755eb3a4b6bbdfb75c78a492e8c56a22c5c4d7e429bfdbc32b9d4ad5aa04a1f076e62fea19eef51acd0657c22", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"},
- TestHash{"79407d3b5916b59c3e30b09822974791c313fb9ecc849e406f23592d04f625dc8c709b98b43b3852b337216179aa7fc7", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"},
- }
- for v, _ in test_vectors {
- computed := sha3.hash_384(v.str)
- computed_str := hex_string(computed[:])
- expect(t, computed_str == v.hash, fmt.tprintf("Expected: %s for input of %s, but got %s instead", v.hash, v.str, computed_str))
- }
-}
-
-@(test)
-test_sha3_512 :: proc(t: ^testing.T) {
- // Test vectors from
- // https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/examples/sha_all.pdf
- // https://www.di-mgt.com.au/sha_testvectors.html
- test_vectors := [?]TestHash {
- TestHash{"a69f73cca23a9ac5c8b567dc185a756e97c982164fe25859e0d1dcc1475c80a615b2123af1f5f94c11e3e9402c3ac558f500199d95b6d3e301758586281dcd26", ""},
- TestHash{"b751850b1a57168a5693cd924b6b096e08f621827444f70d884f5d0240d2712e10e116e9192af3c91a7ec57647e3934057340b4cf408d5a56592f8274eec53f0", "abc"},
- TestHash{"9f9a327944a35988d67effc4fa748b3c07744f736ac70b479d8e12a3d10d6884d00a7ef593690305462e9e9030a67c51636fd346fd8fa0ee28a5ac2aee103d2e", "abcdbcdecdefdefgefghfghighijhi"},
- TestHash{"dbb124a0deda966eb4d199d0844fa0beb0770ea1ccddabcd335a7939a931ac6fb4fa6aebc6573f462ced2e4e7178277803be0d24d8bc2864626d9603109b7891", "jkijkljklmklmnlmnomnopnopq"},
- TestHash{"697f2d856172cb8309d6b8b97dac4de344b549d4dee61edfb4962d8698b7fa803f4f93ff24393586e28b5b957ac3d1d369420ce53332712f997bd336d09ab02a", "a"},
- TestHash{"5679e353bc8eeea3e801ca60448b249bcfd3ac4a6c3abe429a807bcbd4c9cd12da87a5a9dc74fde64c0d44718632cae966b078397c6f9ec155c6a238f2347cf1", "01234567012345670123456701234567"},
- TestHash{"04a371e84ecfb5b8b77cb48610fca8182dd457ce6f326a0fd3d7ec2f1e91636dee691fbe0c985302ba1b0d8dc78c086346b533b49c030d99a27daf1139d6e75e", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"},
- TestHash{"afebb2ef542e6579c50cad06d2e578f9f8dd6881d7dc824d26360feebf18a4fa73e3261122948efcfd492e74e82e2189ed0fb440d187f382270cb455f21dd185", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"},
- }
- for v, _ in test_vectors {
- computed := sha3.hash_512(v.str)
- computed_str := hex_string(computed[:])
- expect(t, computed_str == v.hash, fmt.tprintf("Expected: %s for input of %s, but got %s instead", v.hash, v.str, computed_str))
- }
-}
-
-@(test)
-test_shake_128 :: proc(t: ^testing.T) {
- test_vectors := [?]TestHash {
- TestHash{"7f9c2ba4e88f827d616045507605853e", ""},
- TestHash{"f4202e3c5852f9182a0430fd8144f0a7", "The quick brown fox jumps over the lazy dog"},
- TestHash{"853f4538be0db9621a6cea659a06c110", "The quick brown fox jumps over the lazy dof"},
- }
- for v, _ in test_vectors {
- computed := shake.hash_128(v.str)
- computed_str := hex_string(computed[:])
- expect(t, computed_str == v.hash, fmt.tprintf("Expected: %s for input of %s, but got %s instead", v.hash, v.str, computed_str))
- }
-}
-
-@(test)
-test_shake_256 :: proc(t: ^testing.T) {
- test_vectors := [?]TestHash {
- TestHash{"46b9dd2b0ba88d13233b3feb743eeb243fcd52ea62b81b82b50c27646ed5762f", ""},
- TestHash{"2f671343d9b2e1604dc9dcf0753e5fe15c7c64a0d283cbbf722d411a0e36f6ca", "The quick brown fox jumps over the lazy dog"},
- TestHash{"46b1ebb2e142c38b9ac9081bef72877fe4723959640fa57119b366ce6899d401", "The quick brown fox jumps over the lazy dof"},
- }
- for v, _ in test_vectors {
- computed := shake.hash_256(v.str)
- computed_str := hex_string(computed[:])
- expect(t, computed_str == v.hash, fmt.tprintf("Expected: %s for input of %s, but got %s instead", v.hash, v.str, computed_str))
- }
-}
-
-@(test)
-test_keccak_512 :: proc(t: ^testing.T) {
- // Test vectors from
- // https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/examples/sha_all.pdf
- // https://www.di-mgt.com.au/sha_testvectors.html
- test_vectors := [?]TestHash {
- TestHash{"0eab42de4c3ceb9235fc91acffe746b29c29a8c366b7c60e4e67c466f36a4304c00fa9caf9d87976ba469bcbe06713b435f091ef2769fb160cdab33d3670680e", ""},
- TestHash{"18587dc2ea106b9a1563e32b3312421ca164c7f1f07bc922a9c83d77cea3a1e5d0c69910739025372dc14ac9642629379540c17e2a65b19d77aa511a9d00bb96", "abc"},
- }
- for v, _ in test_vectors {
- computed := keccak.hash_512(v.str)
- computed_str := hex_string(computed[:])
- expect(t, computed_str == v.hash, fmt.tprintf("Expected: %s for input of %s, but got %s instead", v.hash, v.str, computed_str))
- }
-}
-
-@(test)
-test_blake2b :: proc(t: ^testing.T) {
- test_vectors := [?]TestHash {
- TestHash{"786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce", ""},
- TestHash{"a8add4bdddfd93e4877d2746e62817b116364a1fa7bc148d95090bc7333b3673f82401cf7aa2e4cb1ecd90296e3f14cb5413f8ed77be73045b13914cdcd6a918", "The quick brown fox jumps over the lazy dog"},
- }
- for v, _ in test_vectors {
- computed := blake2b.hash(v.str)
- computed_str := hex_string(computed[:])
- expect(t, computed_str == v.hash, fmt.tprintf("Expected: %s for input of %s, but got %s instead", v.hash, v.str, computed_str))
- }
-}
-
-@(test)
-test_sm3 :: proc(t: ^testing.T) {
- test_vectors := [?]TestHash {
- TestHash{"1ab21d8355cfa17f8e61194831e81a8f22bec8c728fefb747ed035eb5082aa2b", ""},
- TestHash{"66c7f0f462eeedd9d1f2d46bdc10e4e24167c4875cf2f7a2297da02b8f4ba8e0", "abc"},
- TestHash{"debe9ff92275b8a138604889c18e5a4d6fdb70e5387e5765293dcba39c0c5732", "abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd"},
- TestHash{"5fdfe814b8573ca021983970fc79b2218c9570369b4859684e2e4c3fc76cb8ea", "The quick brown fox jumps over the lazy dog"},
- TestHash{"ca27d14a42fc04c1e5ecf574a95a8c2d70ecb5805e9b429026ccac8f28b20098", "The quick brown fox jumps over the lazy cog"},
- }
- for v, _ in test_vectors {
- computed := sm3.hash(v.str)
- computed_str := hex_string(computed[:])
- expect(t, computed_str == v.hash, fmt.tprintf("Expected: %s for input of %s, but got %s instead", v.hash, v.str, computed_str))
- }
-}
-
-@(test)
-test_siphash_2_4 :: proc(t: ^testing.T) {
- // Test vectors from
- // https://github.com/veorq/SipHash/blob/master/vectors.h
- test_vectors := [?]u64 {
- 0x726fdb47dd0e0e31, 0x74f839c593dc67fd, 0x0d6c8009d9a94f5a, 0x85676696d7fb7e2d,
- 0xcf2794e0277187b7, 0x18765564cd99a68d, 0xcbc9466e58fee3ce, 0xab0200f58b01d137,
- 0x93f5f5799a932462, 0x9e0082df0ba9e4b0, 0x7a5dbbc594ddb9f3, 0xf4b32f46226bada7,
- 0x751e8fbc860ee5fb, 0x14ea5627c0843d90, 0xf723ca908e7af2ee, 0xa129ca6149be45e5,
- 0x3f2acc7f57c29bdb, 0x699ae9f52cbe4794, 0x4bc1b3f0968dd39c, 0xbb6dc91da77961bd,
- 0xbed65cf21aa2ee98, 0xd0f2cbb02e3b67c7, 0x93536795e3a33e88, 0xa80c038ccd5ccec8,
- 0xb8ad50c6f649af94, 0xbce192de8a85b8ea, 0x17d835b85bbb15f3, 0x2f2e6163076bcfad,
- 0xde4daaaca71dc9a5, 0xa6a2506687956571, 0xad87a3535c49ef28, 0x32d892fad841c342,
- 0x7127512f72f27cce, 0xa7f32346f95978e3, 0x12e0b01abb051238, 0x15e034d40fa197ae,
- 0x314dffbe0815a3b4, 0x027990f029623981, 0xcadcd4e59ef40c4d, 0x9abfd8766a33735c,
- 0x0e3ea96b5304a7d0, 0xad0c42d6fc585992, 0x187306c89bc215a9, 0xd4a60abcf3792b95,
- 0xf935451de4f21df2, 0xa9538f0419755787, 0xdb9acddff56ca510, 0xd06c98cd5c0975eb,
- 0xe612a3cb9ecba951, 0xc766e62cfcadaf96, 0xee64435a9752fe72, 0xa192d576b245165a,
- 0x0a8787bf8ecb74b2, 0x81b3e73d20b49b6f, 0x7fa8220ba3b2ecea, 0x245731c13ca42499,
- 0xb78dbfaf3a8d83bd, 0xea1ad565322a1a0b, 0x60e61c23a3795013, 0x6606d7e446282b93,
- 0x6ca4ecb15c5f91e1, 0x9f626da15c9625f3, 0xe51b38608ef25f57, 0x958a324ceb064572,
- }
-
- key: [16]byte
- for i in 0..<16 {
- key[i] = byte(i)
- }
-
- for i in 0..<len(test_vectors) {
- data := make([]byte, i)
- for j in 0..<i {
- data[j] = byte(j)
- }
-
- vector := test_vectors[i]
- computed := siphash.sum_2_4(data[:], key[:])
-
- expect(t, computed == vector, fmt.tprintf("Expected: 0x%x for input of %v, but got 0x%x instead", vector, data, computed))
- }
-} \ No newline at end of file
diff --git a/tests/vendor/build.bat b/tests/vendor/build.bat
index 09754fc40..693d344f4 100644
--- a/tests/vendor/build.bat
+++ b/tests/vendor/build.bat
@@ -1,13 +1,8 @@
-@echo off
-set COMMON=-show-timings -no-bounds-check -vet -strict-style
-set PATH_TO_ODIN==..\..\odin
-
-echo ---
-echo Running vendor:botan tests
-echo ---
-%PATH_TO_ODIN% run botan %COMMON% -out:vendor_botan.exe || exit /b
-
-echo ---
-echo Running vendor:glfw tests
-echo ---
+@echo off
+set COMMON=-show-timings -no-bounds-check -vet -strict-style
+set PATH_TO_ODIN==..\..\odin
+
+echo ---
+echo Running vendor:glfw tests
+echo ---
%PATH_TO_ODIN% run glfw %COMMON% -out:vendor_glfw.exe || exit /b \ No newline at end of file
generated by cgit v1.2.3 (git 2.39.1) at 2026-02-16 05:40:59 +0000