Vendor Yawning Angel's `odin-wycheproof` into `tests/crypto/wycheproof`

Upstream test vectors from [wycheproof](https://github.com/C2SP/wycheproof) have been vendored into the [Odin test-assets](https://github.com/odin-lang/test-assets) repository, and will be downloaded and verified using `tests/core/download_assets.py`.

9 files changed, 2006 insertions, 17 deletions

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 0d2f3f1ca..aee4c1c20 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -139,6 +139,8 @@ jobs:
         run: ./odin test tests/core/normal.odin -file -all-packages -vet -vet-tabs -strict-style -vet-style -warnings-as-errors -disallow-do -define:ODIN_TEST_FANCY=false -define:ODIN_TEST_FAIL_ON_BAD_MEMORY=true -sanitize:address
       - name: Optimized Core library tests
         run: ./odin test tests/core/speed.odin -o:speed -file -all-packages -vet -vet-tabs -strict-style -vet-style -warnings-as-errors -disallow-do -define:ODIN_TEST_FANCY=false -define:ODIN_TEST_FAIL_ON_BAD_MEMORY=true -sanitize:address
+      - name: Wycheproof tests
+        run: ./odin test tests/core/crypto/wycheproof vet -vet-tabs -strict-style -vet-style -vet-cast -warnings-as-errors -disallow-do -o:speed -microarch:native
       - name: Vendor library tests
         run: ./odin test tests/vendor -all-packages -vet -vet-tabs -strict-style -vet-style -warnings-as-errors -disallow-do -define:ODIN_TEST_FANCY=false -define:ODIN_TEST_FAIL_ON_BAD_MEMORY=true -sanitize:address
       - name: Internals tests
@@ -187,7 +189,7 @@ jobs:
       - name: build Odin
         shell: cmd
         run: |
-          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat
+          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
           ./build.bat 1
       - name: Odin version
         run: ./odin version
@@ -196,70 +198,75 @@ jobs:
       - name: Odin check
         shell: cmd
         run: |
-          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat
+          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
           odin check examples/demo -vet
       - name: Odin run
         shell: cmd
         run: |
-          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat
+          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
           odin run examples/demo
       - name: Odin run -debug
         shell: cmd
         run: |
-          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat
+          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
           odin run examples/demo -debug -vet -vet-tabs -strict-style -vet-style -warnings-as-errors -disallow-do
       - name: Odin check examples/all
         shell: cmd
         run: |
-          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat
+          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
           odin check examples/all -vet -vet-tabs -strict-style -vet-style -warnings-as-errors -disallow-do
       - name: Odin check examples/all/sdl3
         shell: cmd
         run: |
-          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat
+          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
           odin check examples/all/sdl3 -vet -vet-tabs -strict-style -vet-style -warnings-as-errors -disallow-do -no-entry-point
       - name: Core library tests
         shell: cmd
         run: |
-          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat
+          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
           odin test tests/core/normal.odin -file -all-packages -vet -vet-tabs -strict-style -vet-style -warnings-as-errors -disallow-do -define:ODIN_TEST_FANCY=false -define:ODIN_TEST_FAIL_ON_BAD_MEMORY=true -sanitize:address
       - name: Optimized core library tests
         shell: cmd
         run: |
-          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat
+          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
           odin test tests/core/speed.odin -o:speed -file -all-packages -vet -vet-tabs -strict-style -vet-style -warnings-as-errors -disallow-do -define:ODIN_TEST_FANCY=false -define:ODIN_TEST_FAIL_ON_BAD_MEMORY=true -sanitize:address
+      - name: Wycheproof tests
+        shell: cmd
+        run: |
+          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
+          odin test tests/core/crypto/wycheproof -vet -vet-tabs -strict-style -vet-style -vet-cast -warnings-as-errors -disallow-do -o:speed -microarch:native
       - name: Vendor library tests
         shell: cmd
         run: |
-          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat
+          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
           copy vendor\lua\5.4\windows\*.dll .
           odin test tests/vendor -all-packages -vet -vet-tabs -strict-style -vet-style -warnings-as-errors -disallow-do -define:ODIN_TEST_FANCY=false -define:ODIN_TEST_FAIL_ON_BAD_MEMORY=true -sanitize:address
       - name: Odin internals tests
         shell: cmd
         run: |
-          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat
+          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
           odin test tests/internal -all-packages -vet -vet-tabs -strict-style -vet-style -warnings-as-errors -disallow-do -define:ODIN_TEST_FANCY=false -define:ODIN_TEST_FAIL_ON_BAD_MEMORY=true -sanitize:address
       - name: Check issues
         shell: cmd
         run: |
-          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat
+          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
           cd tests/issues
           call run.bat
       - name: Check benchmarks
         shell: cmd
         run: |
-          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat
+          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
           odin check tests/benchmark -vet -strict-style -no-entry-point
       - name: Odin documentation tests
         shell: cmd
         run: |
-          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat
+          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
           cd tests\documentation
           call build.bat
       - name: Odin check examples/all for Windows 32bits
         shell: cmd
         run: |
-          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat
+          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
           odin check examples/all -strict-style -target:windows_i386
 
   build_linux_riscv64:
diff --git a/tests/core/assets/Wycheproof/.gitignore b/tests/core/assets/Wycheproof/.gitignore
new file mode 100644
index 000000000..94a2dd146
--- /dev/null
+++ b/tests/core/assets/Wycheproof/.gitignore
@@ -0,0 +1 @@
+*.json
\ No newline at end of file
diff --git a/tests/core/crypto/wycheproof/README.md b/tests/core/crypto/wycheproof/README.md
new file mode 100644
index 000000000..29381c9c0
--- /dev/null
+++ b/tests/core/crypto/wycheproof/README.md
@@ -0,0 +1,13 @@
+### odin-wycheproof - Odin core/crypto tests
+#### Yawning Angel (yawning at schwanenlied dot me)
+
+This is a test harness that exercises the [Odin][1] `core/crypto`
+library with corpus from [Wycheproof][2].
+
+```
+$ odin build . -o:speed
+$ ./odin-wycheproof ../wycheproof
+```
+
+[1]: https://odin-lang.org
+[2]: https://github.com/C2SP/wycheproof
diff --git a/tests/core/crypto/wycheproof/helpers.odin b/tests/core/crypto/wycheproof/helpers.odin
new file mode 100644
index 000000000..fb6b3ddf9
--- /dev/null
+++ b/tests/core/crypto/wycheproof/helpers.odin
@@ -0,0 +1,76 @@
+package test_wycheproof
+
+import "core:crypto/hash"
+import "core:fmt"
+import "core:strings"
+
+panic_fn :: proc(arg: any)
+
+hash_name_to_algorithm :: proc(alg_str: string) -> (hash.Algorithm, bool) {
+	alg_enums := [][hash.Algorithm]string {
+		hash.ALGORITHM_NAMES,
+		// The HMAC test vectors omit `-`.
+		#partial [hash.Algorithm]string {
+			.SHA224 = "SHA224",
+			.SHA256 = "SHA256",
+			.SHA384 = "SHA384",
+			.SHA512 = "SHA512",
+			.SHA512_256 = "SHA512/256",
+			.Insecure_SHA1 = "SHA1",
+		},
+	}
+	for &e in alg_enums {
+		for n, alg in e {
+			if n == alg_str {
+				return alg, true
+			}
+		}
+	}
+
+	return .Invalid, false
+}
+
+MAC_ALGORITHM :: enum {
+	Invalid,
+	HMAC,
+	KMAC128,
+	KMAC256,
+	SIPHASH_1_3,
+	SIPHASH_2_4,
+	SIPHASH_4_8,
+}
+
+mac_algorithm :: proc(alg_str: string) -> (MAC_ALGORITHM, hash.Algorithm, string, bool) {
+	PREFIX_HMAC :: "HMAC"
+
+	if strings.has_prefix(alg_str, PREFIX_HMAC) {
+		alg_str_ := strings.trim_prefix(alg_str, PREFIX_HMAC)
+		alg, ok := hash_name_to_algorithm(alg_str_)
+		alg_str_ = fmt.aprintf("hmac/%s", strings.to_lower(alg_str_))
+		return .HMAC, alg, alg_str_, ok
+	}
+
+	ALG_KMAC128 :: "KMAC128"
+	ALG_KMAC256 :: "KMAC256"
+	ALG_SIPHASH_1_3 :: "SipHash-1-3"
+	ALG_SIPHASH_2_4 :: "SipHash-2-4"
+	ALG_SIPHASH_4_8 :: "SipHash-4-8"
+
+	mac_alg := MAC_ALGORITHM.Invalid
+	ok := true
+	switch alg_str {
+	case ALG_KMAC128:
+		mac_alg = .KMAC128
+	case ALG_KMAC256:
+		mac_alg = .KMAC256
+	case ALG_SIPHASH_1_3:
+		mac_alg = .SIPHASH_1_3
+	case ALG_SIPHASH_2_4:
+		mac_alg = .SIPHASH_2_4
+	case ALG_SIPHASH_4_8:
+		mac_alg = .SIPHASH_4_8
+	case:
+		ok = false
+	}
+	return mac_alg, .Invalid, strings.to_lower(alg_str), ok
+}
\ No newline at end of file
diff --git a/tests/core/crypto/wycheproof/helpers_generic.odin b/tests/core/crypto/wycheproof/helpers_generic.odin
new file mode 100644
index 000000000..381005dfa
--- /dev/null
+++ b/tests/core/crypto/wycheproof/helpers_generic.odin
@@ -0,0 +1,10 @@
+#+build !linux
+package test_wycheproof
+
+case_should_panic :: proc(fn: panic_fn, fn_arg: any, panic_str: string) -> bool {
+	panic("helpers: testing for panic is unsupported on this target")
+}
+
+can_test_panic :: proc() -> bool {
+	return false
+}
diff --git a/tests/core/crypto/wycheproof/helpers_linux.odin b/tests/core/crypto/wycheproof/helpers_linux.odin
new file mode 100644
index 000000000..b9f1c0632
--- /dev/null
+++ b/tests/core/crypto/wycheproof/helpers_linux.odin
@@ -0,0 +1,71 @@
+#+build linux
+package test_wycheproof
+
+import "core:log"
+import "core:os"
+import "core:strings"
+import "core:sys/linux"
+
+@(private)
+PIPE_BUF :: 4096
+
+case_should_panic :: proc(fn: panic_fn, fn_arg: any, panic_str: string) -> bool {
+	stderr_pipe: [2]linux.Fd
+
+	if err := linux.pipe2(&stderr_pipe, linux.Open_Flags{}); err != .NONE {
+		log.errorf("panic_case: failed to create pipe: %v", err)
+		return false
+	}
+
+	pid, err := linux.fork()
+	switch {
+	case err != .NONE:
+		log.errorf("panic_case: failed to fork: %v", err)
+		return false
+	case pid == 0:
+		// In the child, redirect stderr to the pipe, run the function that
+		// is supposed to panic, and exit normally.
+		linux.dup2(stderr_pipe[1], 2)
+		fn(fn_arg)
+		os.exit(0)
+	}
+
+	// Parent.
+	defer linux.close(stderr_pipe[0])
+	defer linux.close(stderr_pipe[1])
+
+	// Wait for the child to terminate, and ensure it terminated
+	// abnormally (SIGILL/SIGTRAP).
+	wait_status: u32
+	linux.wait4(pid, &wait_status, linux.Wait_Options{}, nil)
+	if !linux.WIFSIGNALED(wait_status) {
+		log.errorf("panic_case: child did not terminate via signal: %x", wait_status)
+		return false
+	}
+	term_sig := linux.Signal(linux.WTERMSIG(wait_status))
+	if term_sig != .SIGILL && term_sig != .SIGTRAP {
+		log.errorf("panic_case: child terminated via wrong signal: %v", term_sig)
+		return false
+	}
+
+	// Consume the child's stderr output from the pipe buffer.
+	//
+	// Note: POSIX requires PIPE_BUF be >= 512 bytes, Linux defaults
+	// to 4096 bytes.  Either is sufficient to buffer output for our
+	// test cases.
+	buf: [PIPE_BUF]byte
+	n, _ := linux.read(stderr_pipe[0], buf[:])
+	if n == 0 {
+		log.errorf("panic_case: child stderr empty")
+		return false
+	}
+	s := string(buf[:n])
+
+	log.debugf("panic case: child stderr: '%s'", s)
+
+	return strings.contains(s, panic_str)
+}
+
+can_test_panic :: proc() -> bool {
+	return true
+}
diff --git a/tests/core/crypto/wycheproof/main.odin b/tests/core/crypto/wycheproof/main.odin
new file mode 100644
index 000000000..c859bc8f6
--- /dev/null
+++ b/tests/core/crypto/wycheproof/main.odin
@@ -0,0 +1,1269 @@
+package test_wycheproof
+
+import "core:encoding/hex"
+import "core:log"
+import "core:mem"
+import "core:os"
+import "core:slice"
+import "core:strings"
+import "core:testing"
+
+import chacha_simd128 "core:crypto/_chacha20/simd128"
+import chacha_simd256 "core:crypto/_chacha20/simd256"
+import "core:crypto/aegis"
+import "core:crypto/aes"
+import "core:crypto/chacha20"
+import "core:crypto/chacha20poly1305"
+import "core:crypto/ecdh"
+import "core:crypto/ed25519"
+import "core:crypto/hkdf"
+import "core:crypto/hmac"
+import "core:crypto/kmac"
+import "core:crypto/pbkdf2"
+import "core:crypto/siphash"
+import "core:crypto/deoxysii"
+
+// Covered:
+// - crypto/aegis
+//   - aegis128L_test.json
+//   - aegis256_test.json
+// - crypto/aes
+//   - aes_gcm_test.json
+// - crypto/chacha20poly1305
+//   - chacha20_poly1305_test.json
+//   - xchacha20_poly1305_test.json
+// - crypto/ed25519
+//   - ed25519_test.json
+// - crypto/hkdf
+//   - hkdf_sha1_test.json
+//   - hkdf_sha256_test.json
+//   - hkdf_sha384_test.json
+//   - hkdf_sha512_test.json
+// - crypto/hmac (Note: We do not implement SHA-512/224)
+//   - hmac_sha1_test.json
+//   - hmac_sha224_test.json
+//   - hmac_sha256_test.json
+//   - hmac_sha3_224_test.json
+//   - hmac_sha3_256_test.json
+//   - hmac_sha3_384_test.json
+//   - hmac_sha3_512_test.json
+//   - hmac_sha384_test.json
+//   - hmac_sha512_224_test.json
+//   - hmac_sha512_256_test.json
+//   - hmac_sha512_test.json
+//   - hmac_sm3_test.json
+// - crypto/kmac
+//   - kmac128_no_customization_test.json
+//   - kmac256_no_customization_test.json
+// - crypto/pbkdf2
+//   - pbkdf2_hmacsha1_test.json
+//   - pbkdf2_hmacsha224_test.json
+//   - pbkdf2_hmacsha256_test.json
+//   - pbkdf2_hmacsha384_test.json
+//   - pbkdf2_hmacsha512_test.json
+// - crypto/siphash
+//   - siphash_1_3_test.json
+//   - siphash_2_4_test.json
+//   - siphash_4_8_test.json
+// - crypto/x25519
+//   - x25519_test.json
+// - crypto/x448
+//   - x448_test.json
+// - crypto/_weierstrass
+//   - ecdh_secp256r1_ecpoint_test.json
+//   - ecdh_secp384r1_ecpoint_test.json
+//
+// Not covered (not in wycheproof):
+// - crypto/blake2b
+// - crypto/blake2s
+// - crypto/legacy/keccak
+// - crypto/legacy/md5
+// - crypto/tuplehash
+
+ARENA_SIZE :: 4 * 1024 * 1024 // There is no kill like overkill.
+
+BASE_PATH :: ODIN_ROOT + "tests/core/assets/Wycheproof"
+SUFFIX_TEST_JSON :: "_test.json"
+
+@(test)
+print_test_vector_path :: proc(t: ^testing.T) {
+	log.infof("wycheproof path: %s", BASE_PATH)
+}
+
+test_proc :: proc(_: string) -> bool
+
+supported_aegis_impls :: proc() -> [dynamic]aes.Implementation {
+	impls := make([dynamic]aes.Implementation, 0, 2, context.temp_allocator)
+	append(&impls, aes.Implementation.Portable)
+	if aegis.is_hardware_accelerated() {
+		append(&impls, aes.Implementation.Hardware)
+	}
+
+	return impls
+}
+
+@(test)
+test_aead_aegis :: proc(t: ^testing.T) {
+	arena: mem.Arena
+	arena_backing := make([]byte, ARENA_SIZE)
+	defer delete(arena_backing)
+	mem.arena_init(&arena, arena_backing)
+	context.allocator = mem.arena_allocator(&arena)
+
+	files := []string {
+		"aegis128L_test.json",
+		"aegis256_test.json",
+	}
+
+	log.debug("aead/aegis: starting")
+
+	for f in files {
+		mem.free_all() // Probably don't need this, but be safe.
+
+		fn, _ := os.join_path([]string{BASE_PATH, f}, context.allocator)
+
+		test_vectors: Test_Vectors(Aead_Test_Group)
+		load_ok := load(&test_vectors, fn)
+		testing.expectf(t, load_ok, "Unable to load {}", f)
+		if !load_ok {
+			continue
+		}
+
+		for impl in supported_aegis_impls() {
+			testing.expectf(t, test_aead_aegis_impl(&test_vectors, impl), "impl {} failed", impl)
+		}
+	}
+}
+
+test_aead_aegis_impl :: proc(
+	test_vectors: ^Test_Vectors(Aead_Test_Group),
+	impl: aes.Implementation,
+) -> bool {
+	log.debug("aead/aegis/%v: starting", impl)
+
+	num_ran, num_passed, num_failed, num_skipped: int
+	for &test_group in test_vectors.test_groups {
+		for &test_vector in test_group.tests {
+			num_ran += 1
+
+			if comment := test_vector.comment; comment != "" {
+				log.debugf(
+					"aead/aegis/%v/%d: %s: %+v",
+					impl,
+					test_vector.tc_id,
+					comment,
+					test_vector.flags,
+				)
+			} else {
+				log.debugf("aead/aegis/%v/%d: %+v",
+					impl,
+					test_vector.tc_id,
+					test_vector.flags,
+				)
+			}
+
+			key := hexbytes_decode(test_vector.key)
+			iv := hexbytes_decode(test_vector.iv)
+			aad := hexbytes_decode(test_vector.aad)
+			msg := hexbytes_decode(test_vector.msg)
+			ct := hexbytes_decode(test_vector.ct)
+			tag := hexbytes_decode(test_vector.tag)
+
+			if len(iv) == 0 {
+				log.infof(
+					"aead/aegis/%v/%d: skipped, invalid IVs panic",
+					impl,
+					test_vector.tc_id,
+				)
+				num_skipped += 1
+				continue
+			}
+
+			ctx: aegis.Context
+			aegis.init(&ctx, key, impl)
+
+			if result_is_valid(test_vector.result) {
+				ct_ := make([]byte, len(ct))
+				tag_ := make([]byte, len(tag))
+				aegis.seal(&ctx, ct_, tag_, iv, aad, msg)
+
+				ok := hexbytes_compare(test_vector.ct, ct_)
+				if !result_check(test_vector.result, ok) {
+					x := transmute(string)(hex.encode(ct_))
+					log.errorf(
+						"aead/aegis/%v/%d: ciphertext: expected %s actual %s",
+						impl,
+						test_vector.tc_id,
+						test_vector.ct,
+						x,
+					)
+					num_failed += 1
+					continue
+				}
+
+				ok = hexbytes_compare(test_vector.tag, tag_)
+				if !result_check(test_vector.result, ok) {
+					x := transmute(string)(hex.encode(tag_))
+					log.errorf(
+						"aead/aegis/%v/%d: tag: expected %s actual %s",
+						impl,
+						test_vector.tc_id,
+						test_vector.tag,
+						x,
+					)
+					num_failed += 1
+					continue
+				}
+			}
+
+			msg_ := make([]byte, len(msg))
+			ok := aegis.open(&ctx, msg_, iv, aad, ct, tag)
+			if !result_check(test_vector.result, ok) {
+				log.errorf("aead/aegis/%v/%d: decrypt failed", impl, test_vector.tc_id)
+				num_failed += 1
+				continue
+			}
+
+			if ok && !hexbytes_compare(test_vector.msg, msg_) {
+				x := transmute(string)(hex.encode(msg_))
+				log.errorf(
+					"aead/aegis/%v/%d: decrypt msg: expected %s actual %s",
+					impl,
+					test_vector.tc_id,
+					test_vector.msg,
+					x,
+				)
+				num_failed += 1
+				continue
+			}
+
+			num_passed += 1
+		}
+	}
+
+	assert(num_ran == test_vectors.number_of_tests)
+	assert(num_passed + num_failed + num_skipped == num_ran)
+
+	log.infof(
+		"aead/aegis: ran %d, passed %d, failed %d, skipped %d",
+		num_ran,
+		num_passed,
+		num_failed,
+		num_skipped,
+	)
+
+	return num_failed == 0
+}
+
+supported_aes_impls :: proc() -> [dynamic]aes.Implementation {
+	impls := make([dynamic]aes.Implementation, 0, 2)
+	append(&impls, aes.Implementation.Portable)
+	if aes.is_hardware_accelerated() {
+		append(&impls, aes.Implementation.Hardware)
+	}
+
+	return impls
+}
+
+@(test)
+test_aead_aes_gcm :: proc(t: ^testing.T) {
+	arena: mem.Arena
+	arena_backing := make([]byte, ARENA_SIZE)
+	defer delete(arena_backing)
+	mem.arena_init(&arena, arena_backing)
+	context.allocator = mem.arena_allocator(&arena)
+
+	fn, _ := os.join_path([]string{BASE_PATH, "aes_gcm_test.json"}, context.allocator)
+
+	log.debug("aead/aes-gcm: starting")
+
+	test_vectors: Test_Vectors(Aead_Test_Group)
+	assert(load(&test_vectors, fn))
+
+	for impl in supported_aes_impls() {
+		testing.expectf(t, test_aead_aes_gcm_impl(&test_vectors, impl), "impl {} failed", impl)
+	}
+}
+
+test_aead_aes_gcm_impl :: proc(
+	test_vectors: ^Test_Vectors(Aead_Test_Group),
+	impl: aes.Implementation,
+) -> bool {
+	log.debug("aead/aes-gcm/%v: starting", impl)
+
+	num_ran, num_passed, num_failed, num_skipped: int
+	for &test_group in test_vectors.test_groups {
+		for &test_vector in test_group.tests {
+			num_ran += 1
+
+			if comment := test_vector.comment; comment != "" {
+				log.debugf(
+					"aead/aes-gcm/%v/%d: %s: %+v",
+					impl,
+					test_vector.tc_id,
+					comment,
+					test_vector.flags,
+				)
+			} else {
+				log.debugf("aead/aes-gcm/%v/%d: %+v",
+					impl,
+					test_vector.tc_id,
+					test_vector.flags,
+				)
+			}
+
+			key := hexbytes_decode(test_vector.key)
+			iv := hexbytes_decode(test_vector.iv)
+			aad := hexbytes_decode(test_vector.aad)
+			msg := hexbytes_decode(test_vector.msg)
+			ct := hexbytes_decode(test_vector.ct)
+			tag := hexbytes_decode(test_vector.tag)
+
+			if len(iv) == 0 {
+				log.infof(
+					"aead/aes-gcm/%v/%d: skipped, invalid IVs panic",
+					impl,
+					test_vector.tc_id,
+				)
+				num_skipped += 1
+				continue
+			}
+
+			ctx: aes.Context_GCM
+			aes.init_gcm(&ctx, key, impl)
+
+			if result_is_valid(test_vector.result) {
+				ct_ := make([]byte, len(ct))
+				tag_ := make([]byte, len(tag))
+				aes.seal_gcm(&ctx, ct_, tag_, iv, aad, msg)
+
+				ok := hexbytes_compare(test_vector.ct, ct_)
+				if !result_check(test_vector.result, ok) {
+					x := transmute(string)(hex.encode(ct_))
+					log.errorf(
+						"aead/aes-gcm/%v/%d: ciphertext: expected %s actual %s",
+						impl,
+						test_vector.tc_id,
+						test_vector.ct,
+						x,
+					)
+					num_failed += 1
+					continue
+				}
+
+				ok = hexbytes_compare(test_vector.tag, tag_)
+				if !result_check(test_vector.result, ok) {
+					x := transmute(string)(hex.encode(tag_))
+					log.errorf(
+						"aead/aes-gcm/%v/%d: tag: expected %s actual %s",
+						impl,
+						test_vector.tc_id,
+						test_vector.tag,
+						x,
+					)
+					num_failed += 1
+					continue
+				}
+			}
+
+			msg_ := make([]byte, len(msg))
+			ok := aes.open_gcm(&ctx, msg_, iv, aad, ct, tag)
+			if !result_check(test_vector.result, ok) {
+				log.errorf("aead/aes-gcm/%v/%d: decrypt failed", impl, test_vector.tc_id)
+				num_failed += 1
+				continue
+			}
+
+			if ok && !hexbytes_compare(test_vector.msg, msg_) {
+				x := transmute(string)(hex.encode(msg_))
+				log.errorf(
+					"aead/aes-gcm/%v/%d: decrypt msg: expected %s actual %s",
+					impl,
+					test_vector.tc_id,
+					test_vector.msg,
+					x,
+				)
+				num_failed += 1
+				continue
+			}
+
+			num_passed += 1
+		}
+	}
+
+	assert(num_ran == test_vectors.number_of_tests)
+	assert(num_passed + num_failed + num_skipped == num_ran)
+
+	log.infof(
+		"aead/aes-gcm: ran %d, passed %d, failed %d, skipped %d",
+		num_ran,
+		num_passed,
+		num_failed,
+		num_skipped,
+	)
+
+	return num_failed == 0
+}
+
+supported_chacha_impls :: proc() -> [dynamic]chacha20.Implementation {
+	impls := make([dynamic]chacha20.Implementation, 0, 3)
+	append(&impls, chacha20.Implementation.Portable)
+	if chacha_simd128.is_performant() {
+		append(&impls, chacha20.Implementation.Simd128)
+	}
+	if chacha_simd256.is_performant() {
+		append(&impls, chacha20.Implementation.Simd256)
+	}
+
+	return impls
+}
+
+@(test)
+test_aead_chacha20_poly1305 :: proc(t: ^testing.T) {
+	arena: mem.Arena
+	arena_backing := make([]byte, ARENA_SIZE)
+	defer delete(arena_backing)
+	mem.arena_init(&arena, arena_backing)
+	context.allocator = mem.arena_allocator(&arena)
+
+	files := []string {
+		"chacha20_poly1305_test.json",
+		"xchacha20_poly1305_test.json",
+	}
+
+	log.debug("aead/(x)chacha20poly1305: starting")
+
+	for f, i in files {
+		mem.free_all() // Probably don't need this, but be safe.
+
+		fn, _ := os.join_path([]string{BASE_PATH, f}, context.allocator)
+
+		test_vectors: Test_Vectors(Aead_Test_Group)
+		load_ok := load(&test_vectors, fn)
+		testing.expectf(t, load_ok, "Unable to load {}", f)
+		if !load_ok {
+			continue
+		}
+
+		for impl in supported_chacha_impls() {
+			testing.expectf(t, test_aead_chacha20_poly1305_impl(&test_vectors, i == 1, impl), "impl {} failed", impl)
+		}
+	}
+}
+
+test_aead_chacha20_poly1305_impl :: proc(
+	test_vectors: ^Test_Vectors(Aead_Test_Group),
+	is_xchacha: bool,
+	impl: chacha20.Implementation,
+) -> bool {
+	FLAG_INVALID_NONCE_SIZE :: "InvalidNonceSize"
+
+	alg_str := is_xchacha ? "xchacha20poly1305" : "chacha20poly1305"
+
+	num_ran, num_passed, num_failed, num_skipped: int
+	for &test_group in test_vectors.test_groups {
+		for &test_vector in test_group.tests {
+			num_ran += 1
+
+			if comment := test_vector.comment; comment != "" {
+				log.debugf(
+					"aead/%s/%v/%d: %s: %+v",
+					alg_str,
+					impl,
+					test_vector.tc_id,
+					comment,
+					test_vector.flags,
+				)
+			} else {
+				log.debugf("aead/%s/%v/%d: %+v",
+					alg_str,
+					impl,
+					test_vector.tc_id,
+					test_vector.flags,
+				)
+			}
+
+			key := hexbytes_decode(test_vector.key)
+			iv := hexbytes_decode(test_vector.iv)
+			aad := hexbytes_decode(test_vector.aad)
+			msg := hexbytes_decode(test_vector.msg)
+			ct := hexbytes_decode(test_vector.ct)
+			tag := hexbytes_decode(test_vector.tag)
+
+			if slice.contains(test_vector.flags, FLAG_INVALID_NONCE_SIZE) {
+				log.infof(
+					"aead/%s/%v/%d: skipped, invalid nonces panic",
+					alg_str,
+					impl,
+					test_vector.tc_id,
+				)
+				num_skipped += 1
+				continue
+			}
+
+			ctx: chacha20poly1305.Context
+			switch is_xchacha {
+			case true:
+				chacha20poly1305.init_xchacha(&ctx, key, impl)
+			case false:
+				chacha20poly1305.init(&ctx, key, impl)
+			}
+
+			if result_is_valid(test_vector.result) {
+				ct_ := make([]byte, len(ct))
+				tag_ := make([]byte, len(tag))
+				chacha20poly1305.seal(&ctx, ct_, tag_, iv, aad, msg)
+
+				ok := hexbytes_compare(test_vector.ct, ct_)
+				if !result_check(test_vector.result, ok) {
+					x := transmute(string)(hex.encode(ct_))
+					log.errorf(
+						"aead/%s/%v/%d: ciphertext: expected %s actual %s",
+						alg_str,
+						impl,
+						test_vector.tc_id,
+						test_vector.ct,
+						x,
+					)
+					num_failed += 1
+					continue
+				}
+
+				ok = hexbytes_compare(test_vector.tag, tag_)
+				if !result_check(test_vector.result, ok) {
+					x := transmute(string)(hex.encode(tag_))
+					log.errorf(
+						"aead/%s/%v/%d: tag: expected %s actual %s",
+						alg_str,
+						impl,
+						test_vector.tc_id,
+						test_vector.tag,
+						x,
+					)
+					num_failed += 1
+					continue
+				}
+			}
+
+			msg_ := make([]byte, len(msg))
+			ok := chacha20poly1305.open(&ctx, msg_, iv, aad, ct, tag)
+			if !result_check(test_vector.result, ok) {
+				log.errorf("aead/%s/%v/%d: decrypt failed",
+					alg_str,
+					impl,
+					test_vector.tc_id,
+				)
+				num_failed += 1
+				continue
+			}
+
+			if ok && !hexbytes_compare(test_vector.msg, msg_) {
+				x := transmute(string)(hex.encode(msg_))
+				log.errorf(
+					"aead/%s/%v/%d: decrypt msg: expected %s actual %s",
+					alg_str,
+					impl,
+					test_vector.tc_id,
+					test_vector.msg,
+					x,
+				)
+				num_failed += 1
+				continue
+			}
+
+			num_passed += 1
+		}
+	}
+
+	assert(num_ran == test_vectors.number_of_tests)
+	assert(num_passed + num_failed + num_skipped == num_ran)
+
+	log.infof(
+		"aead/%s/%v: ran %d, passed %d, failed %d, skipped %d",
+		alg_str,
+		impl,
+		num_ran,
+		num_passed,
+		num_failed,
+		num_skipped,
+	)
+
+	return num_failed == 0
+}
+
+@(test)
+test_aead_deoxysii :: proc(t: ^testing.T) {
+	ctx: deoxysii.Context
+
+	key: [deoxysii.KEY_SIZE]byte
+	iv: [deoxysii.IV_SIZE]byte
+	tag: [deoxysii.TAG_SIZE]byte
+	buf: [4096]byte
+
+	deoxysii.init(&ctx, key[:])
+	deoxysii.seal(&ctx, buf[:], tag[:], iv[:], nil, buf[:])
+	assert(deoxysii.open(&ctx, buf[:], iv[:], nil, buf[:], tag[:]))
+}
+
+@(test)
+test_eddsa_ed25519 :: proc(t: ^testing.T) {
+	arena: mem.Arena
+	arena_backing := make([]byte, ARENA_SIZE)
+	defer delete(arena_backing)
+	mem.arena_init(&arena, arena_backing)
+	context.allocator = mem.arena_allocator(&arena)
+
+	fn_, _ := os.join_path([]string{BASE_PATH, "ed25519_test.json"}, context.allocator)
+
+	log.debug("eddsa/ed25519: starting")
+
+	test_vectors: Test_Vectors(Eddsa_Test_Group)
+	assert(load(&test_vectors, fn_))
+
+	num_ran, num_passed, num_failed, num_skipped: int
+	for &test_group, i in test_vectors.test_groups {
+		mem.free_all() // Probably don't need this, but be safe.
+		pk_bytes := hexbytes_decode(test_group.public_key.pk)
+
+		pk: ed25519.Public_Key
+		pk_ok := ed25519.public_key_set_bytes(&pk, pk_bytes)
+		testing.expectf(t, pk_ok, "eddsa/ed25519/%d: invalid public key: %s", i, test_group.public_key.pk)
+		if !pk_ok {
+			num_failed += len(test_group.tests)
+			continue
+		}
+
+		for &test_vector in test_group.tests {
+			num_ran += 1
+
+			if comment := test_vector.comment; comment != "" {
+				log.debugf(
+					"eddsa/ed25519/%d: %s: %+v",
+					test_vector.tc_id,
+					comment,
+					test_vector.flags,
+				)
+			} else {
+				log.debugf("eddsa/ed25519/%d: %+v", test_vector.tc_id, test_vector.flags)
+			}
+
+			msg := hexbytes_decode(test_vector.msg)
+			sig := hexbytes_decode(test_vector.sig)
+
+			verify_ok := ed25519.verify(&pk, msg, sig)
+			result_ok := result_check(test_vector.result, verify_ok)
+			testing.expectf(
+			                t,
+			                result_ok,
+					"eddsa/ed25519/%d: verify failed: expected %s actual %v",
+					test_vector.tc_id,
+					test_vector.result,
+					verify_ok,
+			)
+			if !result_ok {
+				num_failed += 1
+				continue
+			}
+			num_passed += 1
+		}
+	}
+
+	assert(num_ran == test_vectors.number_of_tests)
+	assert(num_passed + num_failed + num_skipped == num_ran)
+
+	log.infof(
+		"eddsa/ed25519: ran %d, passed %d, failed %d, skipped %d",
+		num_ran,
+		num_passed,
+		num_failed,
+		num_skipped,
+	)
+}
+
+@(test)
+test_hkdf :: proc(t: ^testing.T) {
+	arena: mem.Arena
+	arena_backing := make([]byte, ARENA_SIZE)
+	defer delete(arena_backing)
+	mem.arena_init(&arena, arena_backing)
+	context.allocator = mem.arena_allocator(&arena)
+
+	log.debug("hkdf: starting")
+
+	files := []string {
+		"hkdf_sha1_test.json",
+		"hkdf_sha256_test.json",
+		"hkdf_sha384_test.json",
+		"hkdf_sha512_test.json",
+	}
+
+	for f in files {
+		mem.free_all() // Probably don't need this, but be safe.
+
+		fn, _ := os.join_path([]string{BASE_PATH, f}, context.allocator)
+
+		test_vectors: Test_Vectors(Hkdf_Test_Group)
+		load_ok := load(&test_vectors, fn)
+		testing.expectf(t, load_ok, "Unable to load {}", f)
+		if !load_ok {
+			continue
+		}
+
+		testing.expectf(t, test_hkdf_impl(&test_vectors), "hkdf failed")
+	}
+}
+
+test_hkdf_impl :: proc(test_vectors: ^Test_Vectors(Hkdf_Test_Group)) -> bool {
+	PREFIX_HKDF :: "HKDF-"
+	FLAG_SIZE_TOO_LARGE :: "SizeTooLarge"
+
+	alg_str := strings.trim_prefix(test_vectors.algorithm, PREFIX_HKDF)
+	alg, ok := hash_name_to_algorithm(alg_str)
+	if !ok {
+		return false
+	}
+	alg_str = strings.to_lower(alg_str)
+
+	log.debugf("hkdf/%s: starting", alg_str)
+
+	num_ran, num_passed, num_failed, num_skipped: int
+	for &test_group in test_vectors.test_groups {
+		for &test_vector in test_group.tests {
+			num_ran += 1
+
+			if comment := test_vector.comment; comment != "" {
+				log.debugf(
+					"hkdf/%s/%d: %s: %+v",
+					alg_str,
+					test_vector.tc_id,
+					comment,
+					test_vector.flags,
+				)
+			} else {
+				log.debugf("hkdf/%s/%d: %+v", alg_str, test_vector.tc_id, test_vector.flags)
+			}
+
+			ikm := hexbytes_decode(test_vector.ikm)
+			salt := hexbytes_decode(test_vector.salt)
+			info := hexbytes_decode(test_vector.info)
+
+			if slice.contains(test_vector.flags, FLAG_SIZE_TOO_LARGE) {
+				log.infof(
+					"hkdf/%s/%d: skipped, oversized outputs panic",
+					alg_str,
+					test_vector.tc_id,
+				)
+				num_skipped += 1
+				continue
+			}
+
+			okm_ := make([]byte, test_vector.size)
+			hkdf.extract_and_expand(alg, salt, ikm, info, okm_)
+
+			ok = hexbytes_compare(test_vector.okm, okm_)
+			if !result_check(test_vector.result, ok) {
+				x := transmute(string)(hex.encode(okm_))
+				log.errorf(
+					"hkdf/%s/%d: shared: expected %s actual %s",
+					alg_str,
+					test_vector.tc_id,
+					test_vector.okm,
+					x,
+				)
+				num_failed += 1
+				continue
+			}
+
+			num_passed += 1
+		}
+	}
+
+	assert(num_ran == test_vectors.number_of_tests)
+	assert(num_passed + num_failed + num_skipped == num_ran)
+
+	log.infof(
+		"hkdf/%s: ran %d, passed %d, failed %d, skipped %d",
+		alg_str,
+		num_ran,
+		num_passed,
+		num_failed,
+		num_skipped,
+	)
+
+	return num_failed == 0
+}
+
+@(test)
+test_mac :: proc(t: ^testing.T) {
+	arena: mem.Arena
+	arena_backing := make([]byte, ARENA_SIZE)
+	defer delete(arena_backing)
+	mem.arena_init(&arena, arena_backing)
+	context.allocator = mem.arena_allocator(&arena)
+
+	log.debug("mac: starting")
+
+	files := []string {
+		"hmac_sha1_test.json",
+		"hmac_sha224_test.json",
+		"hmac_sha256_test.json",
+		"hmac_sha3_224_test.json",
+		"hmac_sha3_256_test.json",
+		"hmac_sha3_384_test.json",
+		"hmac_sha3_512_test.json",
+		"hmac_sha384_test.json",
+		// "hmac_sha512_224_test.json",
+		"hmac_sha512_256_test.json",
+		"hmac_sha512_test.json",
+		"hmac_sm3_test.json",
+		"kmac128_no_customization_test.json",
+		"kmac256_no_customization_test.json",
+		"siphash_1_3_test.json",
+		"siphash_2_4_test.json",
+		"siphash_4_8_test.json",
+	}
+
+	for f in files {
+		mem.free_all() // Probably don't need this, but be safe.
+
+		fn, _ := os.join_path([]string{BASE_PATH, f}, context.allocator)
+
+		test_vectors: Test_Vectors(Mac_Test_Group)
+		load_ok := load(&test_vectors, fn)
+		testing.expectf(t, load_ok, "Unable to load {}", f)
+		if !load_ok {
+			continue
+		}
+
+		testing.expectf(t, test_mac_impl(&test_vectors), "hkdf failed")
+	}
+}
+
+test_mac_impl :: proc(test_vectors: ^Test_Vectors(Mac_Test_Group)) -> bool {
+	PREFIX_HMAC :: "HMAC"
+	PREFIX_KMAC :: "KMAC"
+
+	mac_alg, hmac_alg, alg_str, ok := mac_algorithm(test_vectors.algorithm)
+	if !ok {
+		log.errorf("mac: unsupported algorith: %s", test_vectors.algorithm)
+		return false
+	}
+
+	log.debugf("%s: starting", alg_str)
+
+	num_ran, num_passed, num_failed, num_skipped: int
+	for &test_group in test_vectors.test_groups {
+		for &test_vector in test_group.tests {
+			num_ran += 1
+
+			if comment := test_vector.comment; comment != "" {
+				log.debugf(
+					"%s/%d: %s: %+v",
+					alg_str,
+					test_vector.tc_id,
+					comment,
+					test_vector.flags,
+				)
+			} else {
+				log.debugf("%s/%d: %+v", alg_str, test_vector.tc_id, test_vector.flags)
+			}
+
+			key := hexbytes_decode(test_vector.key)
+			msg := hexbytes_decode(test_vector.msg)
+
+			tag_ := make([]byte, len(test_vector.tag) / 2)
+
+			#partial switch mac_alg {
+			case .HMAC:
+				ctx: hmac.Context
+				hmac.init(&ctx, hmac_alg, key)
+				hmac.update(&ctx, msg)
+				if l := hmac.tag_size(&ctx); l == len(tag_) {
+					hmac.final(&ctx, tag_)
+				} else {
+					// Our hmac package does not support truncation.
+					tmp := make([]byte, l)
+					hmac.final(&ctx, tmp)
+					copy(tag_, tmp)
+				}
+			case .KMAC128, .KMAC256:
+				ctx: kmac.Context
+				#partial switch mac_alg {
+				case .KMAC128:
+					kmac.init_128(&ctx, key, nil)
+				case .KMAC256:
+					kmac.init_256(&ctx, key, nil)
+				}
+				kmac.update(&ctx, msg)
+				kmac.final(&ctx, tag_)
+			case .SIPHASH_1_3:
+				siphash.sum_1_3(msg, key, tag_)
+			case .SIPHASH_2_4:
+				siphash.sum_2_4(msg, key, tag_)
+			case .SIPHASH_4_8:
+				siphash.sum_4_8(msg, key, tag_)
+			}
+
+			ok = hexbytes_compare(test_vector.tag, tag_)
+			if !result_check(test_vector.result, ok) {
+				x := transmute(string)(hex.encode(tag_))
+				log.errorf(
+					"%s/%d: tag: expected %s actual %s",
+					alg_str,
+					test_vector.tc_id,
+					test_vector.tag,
+					x,
+				)
+				num_failed += 1
+				continue
+			}
+
+			num_passed += 1
+		}
+	}
+
+	assert(num_ran == test_vectors.number_of_tests)
+	assert(num_passed + num_failed + num_skipped == num_ran)
+
+	log.infof(
+		"%s: ran %d, passed %d, failed %d, skipped %d",
+		alg_str,
+		num_ran,
+		num_passed,
+		num_failed,
+		num_skipped,
+	)
+
+	return num_failed == 0
+}
+
+@(test)
+test_pbkdf2 :: proc(t: ^testing.T) {
+	arena: mem.Arena
+	arena_backing := make([]byte, ARENA_SIZE)
+	defer delete(arena_backing)
+	mem.arena_init(&arena, arena_backing)
+	context.allocator = mem.arena_allocator(&arena)
+
+	log.debug("pbkdf2: starting")
+
+	files := []string {
+		"pbkdf2_hmacsha1_test.json",
+		"pbkdf2_hmacsha224_test.json",
+		"pbkdf2_hmacsha256_test.json",
+		"pbkdf2_hmacsha384_test.json",
+		"pbkdf2_hmacsha512_test.json",
+	}
+
+	for f in files {
+		mem.free_all() // Probably don't need this, but be safe.
+
+		fn, _ := os.join_path([]string{BASE_PATH, f}, context.allocator)
+
+		test_vectors: Test_Vectors(Pbkdf_Test_Group)
+		load_ok := load(&test_vectors, fn)
+		testing.expectf(t, load_ok, "Unable to load {}", f)
+		if !load_ok {
+			continue
+		}
+
+		testing.expectf(t, test_pbkdf2_impl(&test_vectors), "pbkdf2 failed")
+	}
+}
+
+test_pbkdf2_impl :: proc(
+	test_vectors: ^Test_Vectors(Pbkdf_Test_Group),
+) -> bool {
+	PREFIX_PBKDF_HMAC :: "PBKDF2-HMAC"
+	FLAG_LARGE_ITERATION_COUNT :: "LargeIterationCount"
+
+	alg_str := strings.trim_prefix(test_vectors.algorithm, PREFIX_PBKDF_HMAC)
+	alg, ok := hash_name_to_algorithm(alg_str)
+	if !ok {
+		return false
+	}
+	alg_str = strings.to_lower(alg_str)
+
+	log.debugf("pbkdf2/hmac-%s: starting", alg_str)
+
+	num_ran, num_passed, num_failed, num_skipped: int
+	for &test_group in test_vectors.test_groups {
+		for &test_vector in test_group.tests {
+			num_ran += 1
+
+			if comment := test_vector.comment; comment != "" {
+				log.debugf(
+					"pbkdf2/hmac-%s/%d: %s: %+v",
+					alg_str,
+					test_vector.tc_id,
+					comment,
+					test_vector.flags,
+				)
+			} else {
+				log.debugf("pbkdf2/hmac-%s/%d: %+v", alg_str, test_vector.tc_id, test_vector.flags)
+			}
+
+			if slice.contains(test_vector.flags, FLAG_LARGE_ITERATION_COUNT) {
+				log.infof(
+					"pbkdf2/hmac-%s/%d: skipped, takes fucking forever",
+					alg_str,
+					test_vector.tc_id,
+				)
+				num_skipped += 1
+				continue
+			}
+
+			password := hexbytes_decode(test_vector.password)
+			salt := hexbytes_decode(test_vector.salt)
+
+			dk_ := make([]byte, test_vector.dk_len)
+			pbkdf2.derive(alg, password, salt, test_vector.iteration_count, dk_)
+
+			ok = hexbytes_compare(test_vector.dk, dk_)
+			if !result_check(test_vector.result, ok) {
+				x := transmute(string)(hex.encode(dk_))
+				log.errorf(
+					"pbkdf2/hmac-%s/%d: shared: expected %s actual %s",
+					alg_str,
+					test_vector.tc_id,
+					test_vector.dk,
+					x,
+				)
+				num_failed += 1
+				continue
+			}
+
+			num_passed += 1
+		}
+	}
+
+	assert(num_ran == test_vectors.number_of_tests)
+	assert(num_passed + num_failed + num_skipped == num_ran)
+
+	log.infof(
+		"pbkdf2/%s: ran %d, passed %d, failed %d, skipped %d",
+		alg_str,
+		num_ran,
+		num_passed,
+		num_failed,
+		num_skipped,
+	)
+
+	return num_failed == 0
+}
+
+@(test)
+test_ecdh :: proc(t: ^testing.T) {
+	arena: mem.Arena
+	arena_backing := make([]byte, ARENA_SIZE)
+	defer delete(arena_backing)
+	mem.arena_init(&arena, arena_backing)
+	context.allocator = mem.arena_allocator(&arena)
+
+	PREFIX_TEST_ECDH :: "ecdh_"
+	SUFFIX_TEST_ECPOINT :: "_ecpoint"
+
+	files := []string {
+		"ecdh_secp256r1_ecpoint_test.json",
+		"ecdh_secp384r1_ecpoint_test.json",
+		"x25519_test.json",
+		"x448_test.json",
+	}
+
+	log.debug("ecdh: starting")
+
+	for f in files {
+		mem.free_all() // Probably don't need this, but be safe.
+
+		fn, _ := os.join_path([]string{BASE_PATH, f}, context.allocator)
+
+		test_vectors: Test_Vectors(Ecdh_Test_Group)
+		load_ok := load(&test_vectors, fn)
+		testing.expectf(t, load_ok, "Unable to load {}", f)
+		if !load_ok {
+			continue
+		}
+
+		alg_str := strings.trim_suffix(f, SUFFIX_TEST_JSON)
+		alg_str = strings.trim_suffix(alg_str, SUFFIX_TEST_ECPOINT)
+		alg_str = strings.trim_prefix(alg_str, PREFIX_TEST_ECDH)
+		testing.expectf(t, test_ecdh_impl(&test_vectors, alg_str), "alg {} failed", alg_str)
+	}
+}
+
+test_ecdh_impl :: proc(
+	test_vectors: ^Test_Vectors(Ecdh_Test_Group),
+	alg_str: string,
+) -> bool {
+	ALG_P256 :: "secp256r1"
+	ALG_P384 :: "secp384r1"
+	ALG_X25519 :: "x25519"
+	ALG_X448 :: "x448"
+
+	// XDH exceptions
+	FLAG_PUBLIC_KEY_TOO_LONG :: "PublicKeyTooLong"
+	FLAG_ZERO_SHARED_SECRET :: "ZeroSharedSecret"
+
+	// ECDH exceptions
+	FLAG_COMPRESSED_POINT :: "CompressedPoint"
+	FLAG_INVALID_CURVE :: "InvalidCurveAttack"
+	FLAG_INVALID_ENCODING :: "InvalidEncoding"
+
+	log.debugf("ecdh/%s: starting", alg_str)
+
+	num_ran, num_passed, num_failed, num_skipped: int
+	for &test_group in test_vectors.test_groups {
+		for &test_vector in test_group.tests {
+			num_ran += 1
+
+			if comment := test_vector.comment; comment != "" {
+				log.debugf("ecdh/%s/%d: %s: %+v", alg_str, test_vector.tc_id, comment, test_vector.flags)
+			} else {
+				log.debugf("ecdh/%s/%d: %+v", alg_str, test_vector.tc_id, test_vector.flags)
+			}
+
+			raw_pub := hexbytes_decode(test_vector.public)
+			raw_priv := hexbytes_decode(test_vector.private)
+
+			curve: ecdh.Curve
+			priv_key: ecdh.Private_Key
+			pub_key: ecdh.Public_Key
+
+			is_nist, is_xdh: bool
+			switch alg_str {
+			case ALG_P256:
+				curve = .SECP256R1
+				// Ugh, ASN.1 :(
+				l := len(raw_priv)
+				if l == 33 {
+					if raw_priv[0] == 0 {
+						raw_priv = raw_priv[1:]
+					}
+				} else if l < 32 {
+					// left-pad.odin
+					tmp := make([]byte, 32)
+					copy(tmp[32-l:], raw_priv)
+					raw_priv = tmp
+				}
+				is_nist = true
+			case ALG_P384:
+				curve = .SECP384R1
+				// Ugh, ASN.1 :(
+				l := len(raw_priv)
+				if l == 49 {
+					if raw_priv[0] == 0 {
+						raw_priv = raw_priv[1:]
+					}
+				} else if l < 48 {
+					// left-pad.odin
+					tmp := make([]byte, 48)
+					copy(tmp[48-l:], raw_priv)
+					raw_priv = tmp
+				}
+				is_nist = true
+			case ALG_X25519:
+				curve = .X25519
+				is_xdh = true
+			case ALG_X448:
+				curve = .X448
+				is_xdh = true
+			case:
+				log.errorf("ecdh: unsupported algorithm: %s", alg_str)
+				return false
+			}
+
+			if ok := ecdh.private_key_set_bytes(&priv_key, curve, raw_priv); !ok {
+				log.errorf(
+					"ecdh/%s/%d: failed to deserialize private_key: %s %d %x",
+					alg_str,
+					test_vector.tc_id,
+					test_vector.private,
+					len(raw_priv),
+					raw_priv,
+				)
+				num_failed += 1
+				continue
+			}
+
+			if ok := ecdh.public_key_set_bytes(&pub_key, curve, raw_pub); !ok {
+				if is_nist {
+					if slice.contains(test_vector.flags, FLAG_COMPRESSED_POINT) {
+						num_passed += 1
+						continue
+					}
+					if slice.contains(test_vector.flags, FLAG_INVALID_CURVE) {
+						num_passed += 1
+						continue
+					}
+					if slice.contains(test_vector.flags, FLAG_INVALID_ENCODING) {
+						num_passed += 1
+						continue
+					}
+				}
+				if slice.contains(test_vector.flags, FLAG_PUBLIC_KEY_TOO_LONG) {
+					num_passed += 1
+					continue
+				}
+
+				log.errorf(
+					"ecdh/%s/%d: failed to deserialize public_key: %s",
+					alg_str,
+					test_vector.tc_id,
+					test_vector.public,
+				)
+				num_failed += 1
+				continue
+			}
+
+			shared := make([]byte, ecdh.SHARED_SECRET_SIZES[curve])
+
+			ok := ecdh.ecdh(&priv_key, &pub_key, shared)
+			if !ok {
+				if is_xdh && slice.contains(test_vector.flags, FLAG_ZERO_SHARED_SECRET) {
+					num_passed += 1
+					continue
+				}
+				// unused: x := transmute(string)(hex.encode(shared))
+				log.errorf(
+					"ecdh/%s/%d: ecdh failed",
+					alg_str,
+					test_vector.tc_id,
+				)
+				num_failed += 1
+				continue
+			}
+
+			ok = hexbytes_compare(test_vector.shared, shared)
+			// "acceptable" results are fine from here because we have
+			// checked for the all-zero shared secret XDH case already.
+			if !result_check(test_vector.result, ok, false) {
+				x := transmute(string)(hex.encode(shared))
+				log.errorf(
+					"ecdh/%s/%d: shared: expected %s actual %s",
+					alg_str,
+					test_vector.tc_id,
+					test_vector.shared,
+					x,
+				)
+				num_failed += 1
+				continue
+			}
+
+			num_passed += 1
+		}
+	}
+
+	assert(num_ran == test_vectors.number_of_tests)
+	assert(num_passed + num_failed + num_skipped == num_ran)
+
+	log.infof(
+		"ecdh/%s: ran %d, passed %d, failed %d, skipped %d",
+		alg_str,
+		num_ran,
+		num_passed,
+		num_failed,
+		num_skipped,
+	)
+
+	return num_failed == 0
+}
diff --git a/tests/core/crypto/wycheproof/schemas.odin b/tests/core/crypto/wycheproof/schemas.odin
new file mode 100644
index 000000000..754ca06b2
--- /dev/null
+++ b/tests/core/crypto/wycheproof/schemas.odin
@@ -0,0 +1,200 @@
+package test_wycheproof
+
+import "core:bytes"
+import "core:encoding/hex"
+@(require) import "core:encoding/json"
+@(require) import "core:log"
+@(require) import "core:os"
+
+Hex_Bytes :: string
+
+hexbytes_compare :: proc(x: Hex_Bytes, b: []byte, allocator := context.allocator) -> bool {
+	dst := hexbytes_decode(x)
+	defer delete(dst)
+
+	return bytes.equal(dst, b)
+}
+
+hexbytes_decode :: proc(x: Hex_Bytes, allocator := context.allocator) -> []byte {
+	dst, ok := hex.decode(transmute([]byte)(x), allocator)
+	if !ok {
+		panic("wycheproof/common/Hex_Bytes: invalid hex encoding")
+	}
+
+	return dst
+}
+
+Result :: string
+
+result_check :: proc(r: Result, ok: bool, is_strict := true) -> bool {
+	switch r {
+	case "valid":
+		return ok
+	case "invalid":
+		return !ok
+	case "acceptable":
+		return !is_strict && ok
+	case:
+		panic("wycheproof/common/Result: invalid result string")
+	}
+}
+
+result_is_valid :: proc(r: Result) -> bool {
+	return r == "valid"
+}
+
+result_is_invalid :: proc(r: Result) -> bool {
+	return r == "invalid"
+}
+
+
+// The type namings are not following Odin convention, to better match
+// the schema, though the fields do.
+
+load :: proc(tvs: ^$T/Test_Vectors, fn: string) -> bool {
+	raw_json, err := os.read_entire_file_from_path(fn, context.allocator)
+	if err != os.ERROR_NONE {
+		log.error("failed to load raw JSON")
+		return false
+	}
+
+	if err := json.unmarshal(raw_json, tvs); err != nil {
+		log.errorf("failed to parse JSON: %v", err)
+		return false
+	}
+
+	return true
+}
+
+Test_Vectors :: struct($Test_Group: typeid) {
+	algorithm:         string                       `json:"algorithm"`,
+	generator_version: string                       `json:"generatorVersion"`,
+	number_of_tests:   int                          `json:"numberOfTests"`,
+	header:            []string                     `json:"header"`,
+	notes:             map[string]Test_Vectors_Note `json:"notes"`,
+	schema:            string                       `json:"schema"`,
+	test_groups:       []Test_Group                 `json:"testGroups"`,
+}
+
+Test_Vectors_Note :: struct {
+	bug_type:    string   `json:"bugType"`,
+	description: string   `json:"description"`,
+	links:       []string `json:"links"`,
+}
+
+Aead_Test_Group :: struct {
+	iv_size:  int                `json:"ivSize"`,
+	key_size: int                `json:"keySize"`,
+	tag_size: int                `json:"tagSize"`,
+	tests:    []Aead_Test_Vector `json:"tests"`,
+}
+
+Aead_Test_Vector :: struct {
+	tc_id:   int       `json:"tcId"`,
+	comment: string    `json:"comment"`,
+	key:     Hex_Bytes `json:"key"`,
+	iv:      Hex_Bytes `json:"iv"`,
+	aad:     Hex_Bytes `json:"aad"`,
+	msg:     Hex_Bytes `json:"msg"`,
+	ct:      Hex_Bytes `json:"ct"`,
+	tag:     Hex_Bytes `json:"tag"`,
+	result:  Result    `json:"result"`,
+	flags:   []string  `json:"flags"`,
+}
+
+Hkdf_Test_Group :: struct {
+	key_size: int                `json:"keySize"`,
+	tests:    []Hkdf_Test_Vector `json:"tests"`,
+}
+
+Hkdf_Test_Vector :: struct {
+	tc_id:   int       `json:"tcId"`,
+	comment: string    `json:"comment"`,
+	ikm:     Hex_Bytes `json:"ikm"`,
+	salt:    Hex_Bytes `json:"salt"`,
+	info:    Hex_Bytes `json:"info"`,
+	size:    int       `json:"size"`,
+	okm:     Hex_Bytes `json:"okm"`,
+	result:  Result    `json:"result"`,
+	flags:   []string  `json:"flags"`,
+}
+
+Mac_Test_Group :: struct {
+	key_size: int               `json:"keySize"`,
+	tag_size: int               `json:"tagSize"`,
+	tests:    []Mac_Test_Vector `json:"tests"`,
+}
+
+Mac_Test_Vector :: struct {
+	tc_id:   int       `json:"tcId"`,
+	comment: string    `json:"comment"`,
+	key:     Hex_Bytes `json:"key"`,
+	msg:     Hex_Bytes `json:"msg"`,
+	tag:     Hex_Bytes `json:"tag"`,
+	result:  Result    `json:"result"`,
+	flags:   []string `json:"flags"`,
+}
+
+Ecdh_Test_Group :: struct {
+	curve: string             `json:"curve"`,
+	tests: []Ecdh_Test_Vector `json:"tests"`,
+}
+
+Ecdh_Test_Vector :: struct {
+	tc_id:   int       `json:"tcId"`,
+	comment: string    `json:"comment"`,
+	public:  Hex_Bytes `json:"public"`,
+	private: Hex_Bytes `json:"private"`,
+	shared:  Hex_Bytes `json:"shared"`,
+	result:  Result    `json:"result"`,
+	flags:   []string  `json:"flags"`,
+}
+
+Eddsa_Test_Group :: struct {
+	public_key:     Eddsa_Key         `json:"publicKey"`,
+	public_key_der: Hex_Bytes         `json:"publicKeyDer"`,
+	public_key_pem: string            `json:"publicKeyPem"`,
+	public_key_jwk: Eddsa_Jwk         `json:"publicKeyJwk"`,
+	type:           string            `json:"type"`,
+	tests:          []Dsa_Test_Vector `json:"tests"`,
+}
+
+Eddsa_Key :: struct {
+	type:     string    `json:"type"`,
+	curve:    string    `json:"curve"`,
+	key_size: int       `json:"keySize"`,
+	pk:       Hex_Bytes `json:"pk"`,
+}
+
+Eddsa_Jwk :: struct {
+	kid: string `json:"kid"`,
+	crv: string `json:"crv"`,
+	kty: string `json:"kty"`,
+	x:   string `json:"x"`,
+}
+
+Dsa_Test_Vector :: struct {
+	tc_id:   int       `json:"tcId"`,
+	comment: string    `json:"comment"`,
+	msg:     Hex_Bytes `json:"msg"`,
+	sig:     Hex_Bytes `json:"sig"`,
+	result:  Result    `json:"result"`,
+	flags:   []string  `json:"flags"`,
+}
+
+Pbkdf_Test_Group :: struct {
+	type:  string              `json:"type"`,
+	tests: []Pbkdf_Test_Vector `json:"tests"`,
+}
+
+Pbkdf_Test_Vector :: struct {
+	tc_id:           int       `json:"tcId"`,
+	comment:         string    `json:"comment"`,
+	password:        Hex_Bytes `json:"password"`,
+	salt:            Hex_Bytes `json:"salt"`,
+	iteration_count: u32       `json:"iterationCount"`,
+	dk_len:          int       `json:"dkLen"`,
+	dk:              Hex_Bytes `json:"dk"`,
+	result:          Result    `json:"result"`,
+	flags:           []string  `json:"flags"`,
+}
diff --git a/tests/core/download_assets.py b/tests/core/download_assets.py
index b39aa059e..c280bb9c2 100644
--- a/tests/core/download_assets.py
+++ b/tests/core/download_assets.py
@@ -6,8 +6,11 @@ import os
 import zipfile
 import hashlib
 import hmac
+import sys
+import io
+sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
 
-TEST_SUITES        = ['PNG', 'XML', 'BMP', 'JPG']
+TEST_SUITES        = ['PNG', 'XML', 'BMP', 'JPG', 'Wycheproof']
 DOWNLOAD_BASE_PATH = sys.argv[1] + "/{}"
 ASSETS_BASE_URL    = "https://raw.githubusercontent.com/odin-lang/test-assets/master/{}/{}"
 HMAC_KEY           = "https://odin-lang.org"
@@ -285,6 +288,344 @@ HMAC_DIGESTS = {
 	'emblem-1024-gray.jpg':        "4c25aaab92451e0452cdb165833b2b5a51978c2571de9d053950944667847666ba198d3001291615acda098ebe45b7d2d53c210c492f077b04a6bfe386f8a5fd",
 
 	'unicode.xml':                 "e0cdc94f07fdbb15eea811ed2ae6dcf494a83d197dafe6580c740270feb0d8f5f7146d4a7d4c2d2ea25f8bd9678bc986123484b39399819a6b7262687959d1ae",
+
+	'a128cbc_hs256_test.json':           "4d2c8e5c9c669dba8f4ca88398efaa03003a1f0350a50df6ad94fbc5d93cb9b9ab6f96b727e1bf85298e98b5d5cf2538d38fab745ceca65cd35bf8dd7562ce87",
+	'a192cbc_hs384_test.json':           "3de5725108dc43dfe49571de089488de035631ff378c7708bd51fcdc854f306ca47cf731c65e45662759c8aed232f5111101d6c33836d9c2f8f700e775b8aa82",
+	'a256cbc_hs512_test.json':           "ea178a43c0bdf5ba8be435364424829e6d507bd90d5fd946b7c0f95190377f97de9b54c000049ca380d71d64b5e28e3d8977132143243e05559d878311c84c02",
+	'aead_aes_siv_cmac_test.json':           "b6de9c2559952f0eef286c1d28fd03c2cad4b73f006d3f74fc9f3de9a2c6d213c1851e126d29aa2d40ead31a01caaf301e00bacda7febbf303eabc76097396b4",
+	'aegis128L_test.json':           "be6f45c99c7814626c108f668aff5577196e8f9500074b3bef2541b16396c6444116108aecb61f0a1fa043a45e9216319fe4e82794eed93c95838e491b1d5571",
+	'aegis128_test.json':           "334996ec6b297bcb3410d13cfe10d63d884c8e90219a958d50b05adb0ff45acf80a215ca34de92756964f4cadf487734bd8443d67f668e292edd24228e55a8cc",
+	'aegis256_test.json':           "e134580630fa642024f7b8666f05d53b7e013c6f34614f9e5df1fa272348c8cf30e9ec34d1c7fffcb0c40f13e6a2ac1273e54670ecb6a6851e1ae59f0b6dc623",
+	'aes_cbc_pkcs5_test.json':           "42ad3d7ccc3409521db3b7d4bcc812b56d5656b0425f93a8d22ada118ee5a1b55c644b162d8074db36dd69b97dce27c8099b0571724eacf0b34bbbb59b4d9e79",
+	'aes_ccm_test.json':           "ad1585b5fe8a5ba90f5ae825f7c318da47d82ad63e98440ecb981ebad9746fdb2139e7801f6f714b3971e5f97a917714d857cda38e66d5b19eb718c404419c8c",
+	'aes_cmac_test.json':           "dfcf3e6effe5c7e2a44c4bd7c39fbff2b3537064f39e1407c28e47e5d4ee7fa29ef4225e44ed83b6b4ef24b87e4cecb84342528ff4d0ec28db529a8d3a1b47e4",
+	'aes_eax_test.json':           "b6ed02c28bd5945feef804ce9af8145f4313bbe6e5c0c4bd09e4138a1b618fe4a48f4fb80359f4dec41e26657840f3e8a9a333fd5edc8a0201924ee49a9b1d37",
+	'aes_ff1_base10_test.json':           "24c3d89a097b993902fe7913d92d1250f11a4371d2376c6715db1f7ca5e958a4bf52bff70b86c0cd6001acd7d12737d67e8ce78548a9c5b8e628bf7cff004a49",
+	'aes_ff1_base16_test.json':           "cd4eb61faee16b09f6f6fc99bfbe29439dec618a710b2a4de291ae44c1c8692f6084910abcc0e1445f022942c22b1078cc860b4696b2aab6e4379e8e63dc6188",
+	'aes_ff1_base26_test.json':           "6f3e6239ce0c0e5213d1c706082989a31519e9198d4f72f2cce8029e2b91aefd5bc522e2040fe807581bc026da659a7cd1c93095382441c3f40bbbeb4ada7f74",
+	'aes_ff1_base32_test.json':           "84b725e1b89ef9e6e28dd3915b5dd5a6d8858cb119cc5e5c91a94311ebe6c68b833005af227ef50987347a1b9f853ede7aa3b250ba9127ee74cbe0f1ee3d8c31",
+	'aes_ff1_base36_test.json':           "f1189ce66cfb610520eb0d9383d2dddf39a2ba04b82eae803c31b59cbddab42bd82f18a1aaacc8206f3ff7bb1dd9a75095534d6f3295baa3a9560f85f279dac2",
+	'aes_ff1_base45_test.json':           "bf370df32834cafe7e71e638d1c034f4540221f052d1a57d8e4ed7e0cbce0dc04d9752246909befcaef8bde6bd43c4336af9d36b2899bfb158becc60bd1b3e35",
+	'aes_ff1_base62_test.json':           "2f74c4f052e9eb70fbc52229a9e7d73313cf7ffa8ece832d4bbe6923a662e2efe549f1c6959440e2aef32cb682d44dbc3d25afe9f46cf60f3cb49494b94cecc9",
+	'aes_ff1_base64_test.json':           "284ce27d4903d94d6e5216290460388749e959f34ab7a4cc5080634f1067fe6c2fadcc9f65aa716793a21e3828b5fa364b5172428b48ae08a38b74c217a89053",
+	'aes_ff1_base85_test.json':           "81c67c4547a39b95db863fe6115d5258d59b345c29f9714f863666b578092a985a1c3af6e140b811c0a501fb70fb5ff23fb3688cd4f31bb47b471a8e4a46ca6e",
+	'aes_ff1_radix10_test.json':           "121ffd39b271aa4ba33d0cca7c8d53a5854825c6c03d91c115b8c0072f50219e60ccfc039297693b2f38cb0878a2198847f212d4f6401c56adc58c2b3b4693d3",
+	'aes_ff1_radix16_test.json':           "d77f9ca3f0e31192c932e8efe2995ce08ae29c214f811220ca817937643d44c71f66ee3775a7b28a5f6cfcff087d864e91077dcec1294c8e7e56a5913c824c67",
+	'aes_ff1_radix255_test.json':           "59201883feddf63968ba6cb685704345ef4a265451e617059df854089e299b6540e32f02171ed84a4d3321eb68da3730f3e2fc0c42d694dd3570f4e3c6ccdf9f",
+	'aes_ff1_radix256_test.json':           "d89f6b91c278af43634db849a981551aad2b8ec9012cb787cb37cf08a5c0e37569202220cbbc9f68857c01f2b307b3ec6a9c255bb5349dd733a5262d402601c5",
+	'aes_ff1_radix26_test.json':           "e21360f98d3bb6fb3e810a844a71e7870dc9892d14c9aa72e9e1c2158a7bae0f2458cc430aca4143f5fdd801a3d0ba256503a7e39a0aba9829e12a6fc4c6135a",
+	'aes_ff1_radix32_test.json':           "b5c74059593c85e902b76eca70bb43683503c7a510f964548830fefb07c71875a79ed0d8bc57df3ff19d3fc0aa6ca383d7a640419c00827bd9a3a44bbc38a541",
+	'aes_ff1_radix36_test.json':           "ca8e530579bcdbba9edad518bf9487bc8cecdbb0f41a523e292cbf1edbd4d48135b04cbc956b46bcdc2ce4749af3a1d223a69622cd1897ae28c03b4a42cf5f3b",
+	'aes_ff1_radix45_test.json':           "6711c5ec7e5bb9d855d12f8dc2b2f863b1d22de03322fda7878ad9350834985e134fda6157adbf87f3284111ff34bde9ca325e155e2f779ac5f32f0ec86d01d1",
+	'aes_ff1_radix62_test.json':           "ded71ce5521e8603b7cefeeadbf448dca6d80394bb73e037e31c7f2018b55c2d1fad727a0969d94d40a3ab3d4d080ce0617b28bc7f2acdfd239e0e281d6420a2",
+	'aes_ff1_radix64_test.json':           "8f663baf03b24e4d81441a5bee3421c268054c4ae175683698e7410a031275d42f25c13e0d0843c6da53e71abd201ce2e53ad4a928e82ff3eaffa2011ba967ef",
+	'aes_ff1_radix65535_test.json':           "9260f514add588a56391bd485b8ce97ebb0592e86bc09b050572368681be7f737f1aedd6ab4ad4bb72fb1a5c2168658243d12da0c167eb16c92e361301393721",
+	'aes_ff1_radix65536_test.json':           "2ffe5c12f6f55c363a3fc5d030d5c2eb7d8d71c14184f069bed0b3d349321831043eb23a35e5a9b79e3f04a8de196bd37438824534a1ba9afeb5ecf29aaa5869",
+	'aes_ff1_radix85_test.json':           "ba5be98fdf9154ac0d7c1369ea7bdd570c7959e45a1be960e6681974f52e4c77ad71eafe68a86c35974e5ec42accdafb35e638a522298fa4ed146f5c3b31cfbb",
+	'aes_gcm_siv_test.json':           "fbd2c29f40d396a247f1c5aa2e8823a6d00e1ceaa390bf0900fa99b793801fa2f3b44a8558d8b178a720fdd003a31ecab8598c7d4c709b783cf29d4a1f1c1fee",
+	'aes_gcm_test.json':           "5a41e50d865cf2e4a206bf96e05bb4f67d74ecd519480ca372d662c64d26dbc954f530c65fd477992de3600c978d3a6447b9e9dbf511a9b2c2ffdac28fbb1d95",
+	'aes_gmac_test.json':           "3226a4f531c8427a9604591e4486e4fb706ab0b57488ef53415303a503b5409c0f4852add453895434cc94771f59a87604dd15d47c861fd904d4bee0e0921b5c",
+	'aes_kwp_test.json':           "f9473060ba0e4e24c0b1938a38d1aed9333ae32109132c0c69701d9e706a8c21579444c046546e218d6982d3d90d5cafc2a99d31e3be432b13dda0b9f627a635",
+	'aes_siv_cmac_test.json':           "a5025be2398884ef5d6b2431db6bb90b9096dbde77f06c353b78d1b35e82f6d5a8e701a025685f95d8412998800293498643017ddc792cee3360c943bbe6590c",
+	'aes_wrap_test.json':           "b569c6aaac4e01df7e91f2ec942f4a32ea17ec789efe50ba640be5596519e1533dd15aba1dfd3aa2ff29077cfd800caf76adc15e1d8e5f31b10492a96a06175e",
+	'aes_xts_test.json':           "66ba73b3270436f8706f32e8d7fdb7e47f5638d10db83cf9311feecf70ac3ff1d66ff9aea528250b92e01177786f90fd06e8df72404de2e5c14ecf4aabc6e790",
+	'aria_cbc_pkcs5_test.json':           "9e8c33fc364d6fec2b541c542d6f822354c3deab61afc37b3c0881388e82e9b1e9c87f28fb6caa639edc765ba362fb98324a232c7f2f7492f6cc794bf57d66a0",
+	'aria_ccm_test.json':           "28bf6139961f41c8bfedf130cf327ac3012c1116f4dbf820416a912f4928ac8e1e4bf9aa0d7681f9ea43de264125fcd3fdb29d4f9ab9d27a0a72287a85d890bd",
+	'aria_cmac_test.json':           "1de6a919708adf65b96ade5dbb29a95e894e904f7f6f1a58cba08da927460982bae16ae8fa167f89a3a2889458b6adfba2a39e07990b0c589db06dbea26b6941",
+	'aria_gcm_test.json':           "663770e79111916abc82309245e64d90a2a75e409aefc17e6965cd183dc843fd810d61f49a3ae8ceaa216cfb9d44782130796f579c5eac75efbe43875678d891",
+	'aria_kwp_test.json':           "65db98e93fc0a7f4bedb3d8056c5bebf35de24e7bf7059299298e520791e232799e5b8dd733d928c349d6345f74b45c5c44f207a3cf1027d2c7c172ca8eeacb5",
+	'aria_wrap_test.json':           "4f1ad34ef5819383d5b999abf3fdaaf66c5801d851e83425162aa77d9873478fbab30be31a23955a1e279052e147ab6984de9c48f63d4d5c9732defb5f15e9a6",
+	'ascon128a_test.json':           "6ee774046ff065ad60c56bffe644ee97b6c617b62a8e291c476854895eb5c49e8c83bcf85fe86a0ad0656e0564bd90bf4ce812e0870c463c2fa50e6fe5672fec",
+	'ascon128_test.json':           "73d81b184dd53fee8f479d99478943349e5a2dbb997c4aa37482fa17d128e4f8664f8f06a0c2ac7f9668b0ab12b2d1378808c6d2b3b96f01225dc41a83366b0d",
+	'ascon80pq_test.json':           "dc2d8093cc93537e11d2672508035b4a366878a8b1e3b2d6bdd6bcd87915cff4835c704ced257e841dbc459e223ad8b5e3db21862626263fe9666e7bdfdc6841",
+	'camellia_cbc_pkcs5_test.json':           "01951132ec42955ce8eb74c1f431f7104212be90e345d16cc01a3cd4639e882f00947fa1009d8500d5b73a76b288cff2ebed7e176662cc862fbe8ddeb3a0fae8",
+	'camellia_ccm_test.json':           "1ac5a769ace83143ec341d4205e42c8dca037c6242af631c04f6590ecf6895420a14ed70910119bdbe1a9272fb703a7cf4df97943087b2db42775cc78fb189a5",
+	'camellia_cmac_test.json':           "ce8ca04c8b8316c56076ea913befa8d468d5a92266d3f381930b5fba4832d7be72046ce9c988ef8103ac0c350187ec8c146ef090a21540df6933dd1c31bab78a",
+	'camellia_wrap_test.json':           "6d261b753a88a10cb813ed9b4ebb25265306582f36998a6761dfa930293d4d3508df609b117aa0d278167fa9ab2e4327165adeff57835935964ecfec5c07307e",
+	'chacha20_poly1305_test.json':           "4edc434f10a9b026c98901aa7a48933e0de03d24f2445ecd9cb30c2e063390f97ff7e0b58b12135a231845e5771cc38c22b07ae814f85cee14f62d6a68ceeaac",
+	'dsa_2048_224_sha224_p1363_test.json':           "3de70432fb46585a0d980b124f33fb15ad5bb700d417ee2d051d00a1521507454ee9d1c41ccac04d79a3a76ae4442f4511cfbbfee66c092348d7c9762309d83c",
+	'dsa_2048_224_sha224_test.json':           "27149b08174f990da4152ff6efefe12c0008e8d24d3385c743d7d5bcaaa97b948da14703156c4142aacdfb324a276f87c1ccffd051fc6261ebc3deec4e9fa101",
+	'dsa_2048_224_sha256_p1363_test.json':           "7605f35381b9802104810b95e34835de72863ed4898cb56d004d55e7523fa5e12552460594ab0bd62c69ac8156113bffccb3118bfeb78f22566e3a210d96bf75",
+	'dsa_2048_224_sha256_test.json':           "c57b50d45969cfbe3ec80fb315179887e48e3b743e4d0c9c0384fb4a19220a7159c4033fc077d98266dde50424a0e186faec875408bfbe80d8c63b5bf00bfece",
+	'dsa_2048_256_sha256_p1363_test.json':           "4ca9c67c5bd4f220025d5725e06b63fb66f2b761f47fac94c84dfb97d433097c6138bd0868ccefa53f5da73d1020e1287dc7152143b125ca141ad27cb5b46c07",
+	'dsa_2048_256_sha256_test.json':           "67d1860659160aee1d13a2008f370db7afdea022278733b6c64e5204efe6aeefb175cb2e4b4f02fbcb845c010e1041757c37386016fc30143c9f13bc55ff8330",
+	'dsa_3072_256_sha256_p1363_test.json':           "806d22e4676f4890be78517f64279ba94b2a4d723985ec6002ed05deddda8610518588422a424410d32f3ed4c93b6ea7b0e8b2dfdc0eab8658b88e47041f9374",
+	'dsa_3072_256_sha256_test.json':           "2a24217dd91e159657c7ab24e26b6f9869a77208ef1c898433d9e10bbb5fd1f00b69e6a3b0ba4c336a8c02fa9208723b5ff782395baf1cd9d7556897cce93975",
+	'ecdh_brainpoolP224r1_test.json':           "0b654d630ad6bf1faf177631daea94b6d68a17fce1e5da0ab0e12702e206b7fc982aff4d331c6b0e55da536f2b648f06dfea0f10cec7b9d5c7845b1da0591732",
+	'ecdh_brainpoolP256r1_test.json':           "3df7d06433c5f85bcc834e598d63ba7ca611f859b1102bcdb0363421f0e8bb60154b13dd3639020504dc80ef44ec1aaa72529467ed503d646ec49b3d566b8b0d",
+	'ecdh_brainpoolP320r1_test.json':           "e3a8cc1e2e028d0cf5926dd507825c863c24ebcbfee685430d80277300bcaca3eb37a1a937b47007e4479bac69bdcd80e83cf3ab583566024b2c15add713311d",
+	'ecdh_brainpoolP384r1_test.json':           "8161986b7d3d061647a051b176306ca7f5f6a7ed55af77a676e3711b8ce9b4c036ddb65aac3a1789c5366fcb4b048946f4c8611fa0fc8af7deb37ec24ea97fa7",
+	'ecdh_brainpoolP512r1_test.json':           "0cec6745113ff9e5b79649470dbfaa95e059cf46cce4cc4ebf5f41ec93bd10974ca17e12aba54f75ea9691ccc50a1f8a031f7dc22cc03c17606e2a9258d8b3bc",
+	'ecdh_secp224r1_ecpoint_test.json':           "63ffedb647198fd97a2aa532175472442169d2c002aac88c8327625fcbe85631614431b5b24172a069311ebbe6ae0aff55f71ac601ec706066caf5268dcd639c",
+	'ecdh_secp224r1_pem_test.json':           "50e094fde7bb6077e7f378be72b03067ab9509aad6e4d473e982d5d3e710236889e81f10158240d9ea74a835b3f4c1cc6a17ef2deaa8715e1b23b77296f1567b",
+	'ecdh_secp224r1_test.json':           "ed1d7c38f5203df529252f01ad7a29c91beb1ea8724d46b7e5c819f9447f9dd28575b97802e17fb12ed9b65f72c10aacdb83e10c5b30c43486a4f37b6440a365",
+	'ecdh_secp256k1_test.json':           "efdde98724a6aa908fb588d79c0ad0dee83534105368b281964223c12e775f947adca5e910dfe457d3da84d8393549c0d753763f4a9461589b60d8adc1b88943",
+	'ecdh_secp256k1_webcrypto_test.json':           "d019b26616a43bbcb9ae42057b6526cdea94025572d141a0644d20547175b845326328dcfef320a9b66b6a6d18e644932336d958372a7be6cc6677c06a3393bd",
+	'ecdh_secp256r1_ecpoint_test.json':           "08a3a91f8269082f1557275e14ddd10270d03d04a2e394a1951c7364042f1ab66c7679df4e86869444fa7704d4f546d8ccae597992532539e53e405a080be7cc",
+	'ecdh_secp256r1_pem_test.json':           "adda0a1ba574fa2e27279d2ab796816dc57c2479ac389c83db2e9467ec3a727d10cb8f05e04741e7cbfcc4966c075ed56ee6f038d3afc09b6e5377b7b035a27d",
+	'ecdh_secp256r1_test.json':           "89eeee692fe4b898530e25c07d4417287cf326f1cafd0a4f1b3e3a206f4faba8a571a6805d31c7106424c597d8131b5201a5f4e0fd64dfa2cb73775f657066be",
+	'ecdh_secp256r1_webcrypto_test.json':           "ab289f42fa6a031ee8569f0a67bba6035f43616a369ae3ea88b5b43356a629b739e8fad3b01fe3055d0f8ba1322f25f94fbfbc8942eaa1a69e0766911dd77401",
+	'ecdh_secp384r1_ecpoint_test.json':           "fc8568f074fa963489d205db2ae25061b725128755b822821d52b2995750882ae1b9be9f5c5daf53b1ff6ae8de223d22d96a64ec5e336c4e671300ad6450cbc0",
+	'ecdh_secp384r1_pem_test.json':           "b9560104ddb35aa7d2454d140dbf71266af689b0298a77d86092766e950fc1a6c99adeaa875be8c5c27fc0ebaf9d4d97f2dc77c45032f7b1d4de030a8f552eb5",
+	'ecdh_secp384r1_test.json':           "60c50e940f92bad9b6ceb4e8cb98cba97774e6bbe62490b4fef53a81a8bf1eac0e8ff18b8250413e7b395dd607bf3946f296adc3e2274747c04481a0ace8158f",
+	'ecdh_secp384r1_webcrypto_test.json':           "db910d22b74b63b0a94f5ce4cf5231d80fde50410a7c118c2ca23f1ef41bf29bb43045d48890871df8ac6a90de0fd58133277acf63ab0524ffacc447e113616e",
+	'ecdh_secp521r1_ecpoint_test.json':           "54cfaa89c2c7716fdb89e38734ab1300496bb4b1794f789a837553f1c4112c65c2498572f101ce16d0000e4ee5e1f1d39a1e1135749101a7c165df8c502b1a2a",
+	'ecdh_secp521r1_pem_test.json':           "076b10984795e5e74da179f5d33807707ce305f877c27dbb67cc7009d09ab678ffa2eb730d445121a152566481a040e6a2f8c6b371262694e95ee632268eb8ca",
+	'ecdh_secp521r1_test.json':           "2c578c3588b0dded23bc1f6b2c3c5cd44824d1d955e92eab77c4d107bfa60965991cc74424a2270a182f92e1c0bd22dd30c1e9dede574eae78f7ee1c17d396d6",
+	'ecdh_secp521r1_webcrypto_test.json':           "3e9c1d6dcf3cfde667a6a0d4c389a7bcb8308095d0f062fb5a633c0a78695789d79f5f8e637dde866cbaa49a7038e690ae7516aa707fd65320feb2b959c32c80",
+	'ecdh_sect283k1_test.json':           "54607e398d77eccf7526d8aff7d5243b238dc00c06c072a1c30c9ad2226d8d6da659b83194a2e4dd0a62369f27f8f44c9a50bc716780bf26bb5869a529835df7",
+	'ecdh_sect283r1_test.json':           "295c73b9daba0acc13fca624d2210c5247b704396b2fe8004d8c62bc5e5434dbda478b547b8b9a7176132de88aba46e1917efb45291561bf8251e284bbf3f257",
+	'ecdh_sect409k1_test.json':           "161840a74cdb562acf49e3e389f743779aac773f2ea3a4e2920b427617211532514cc83788513533cae8487e486787c89e5fe50066e104b43af15aaf46dddc6a",
+	'ecdh_sect409r1_test.json':           "f43791e15318478221f6692558115c31590567a8b969d55e648711023e4164ce60b1998585fc89a1b07f8922722203cc36c48069565710f0d7897d5c8dcc7d0d",
+	'ecdh_sect571k1_test.json':           "b944b9de3b6d3954aeeea4b3ef6b9c7e12cbb25bff6acb385062ec8a35c4e7052384d4c14285f8feb870e9b1042237fbc2e7138db013b5b65edd78f795fb695e",
+	'ecdh_sect571r1_test.json':           "3baa06212ebaef756daee791abbec499ea145dcdbc54758519503550efa2836ea89717b740e59cfc044a61e88ddc2e3892a168f27c27679a1f89701a66999283",
+	'ecdsa_brainpoolP224r1_sha224_p1363_test.json':           "b5f9fec57916ab49d1373cbf55ef441edc481825993fae3b07c42a38c3646e90d28075b8b1cc35157928be74b875fdc990bfda582f83ac8a68009bb9804890f6",
+	'ecdsa_brainpoolP224r1_sha224_test.json':           "f352487bb90f666b6adca5e9c41d48f09c28c69404a884fbff3c6780ded73681e31fdaaf0da1d53a9d8fe964ab4678170ab4f5085e5f551f5e56adab2c9a8e2e",
+	'ecdsa_brainpoolP224r1_sha3_224_test.json':           "ca83567e3e2d62417974066b5cad977b12627418baccdf4dfe9c9a1972af83de6d3869e25a66a986a062862e5cbdfcef2642b72bcc5deb9b78cbbfa3e8d5cef9",
+	'ecdsa_brainpoolP256r1_sha256_p1363_test.json':           "9a41d67ee9f2353bf9d54928564db3f0804c4704838bc67af33eb70a1dbce4af70e449fcc74f98192bca9ab2eb0879604bac34bb87e832a7984fcb12c6d4cdfd",
+	'ecdsa_brainpoolP256r1_sha256_test.json':           "94a6da4a541efc83e29758a2f321d4acc937dff585a9f33ce170f66c0f46c8459db12643e56b41bdbe388d0ea0ad3f6b9a7d3d0cbd58aadc81e66eca4ca68210",
+	'ecdsa_brainpoolP256r1_sha3_256_test.json':           "efca09da2c39791e634fa5910d9ed4fedf9ec22f6858bc65976e4bdfdcf9eb4af2efe793cc39273d2001ed1f5b394826df91a4ee30d37e4f50aec3451b167aff",
+	'ecdsa_brainpoolP320r1_sha384_p1363_test.json':           "a3483693f6dbaf99e0c7669602b64a5f19a14e3451b84558f8aff6a73988b48b46c02c9b95cd17263dad25e32721f602898eb2369c607dd6debf64eb294dfa36",
+	'ecdsa_brainpoolP320r1_sha384_test.json':           "bd2b3290124ca707ac214d0ab0b2f7df44cbe33910f5c690485814333c0fb9df95de39eee99ae392e89dfd151aa1389c89248c5e89e5c9fb9002d159159068e7",
+	'ecdsa_brainpoolP320r1_sha3_384_test.json':           "02ecf9b37ed128edc759b5ee0530960d719bd724fe7ea7f02fd70486e5cb01d9a51e50f9a7cce9e33ac6c053d7b3b6949011863dad17442e5d642825a2004f71",
+	'ecdsa_brainpoolP384r1_sha384_p1363_test.json':           "05b23eb103e9d9ad92e015db8871edc6f0ae88ac02a2f7e9a582328a75779ee09dbc5e30aadf3f0bc8f6ae28ddbda90d4bd2502fd33e4bc60cf6ce99b5e76c97",
+	'ecdsa_brainpoolP384r1_sha384_test.json':           "62c3d506c42a25915cfa8ccc3a7a4d17efe4c725ec95caa94973b30257b08009622035d751d676f857f2e8a2923360db1cfc63c5fcc00963ba877d077d39b2fb",
+	'ecdsa_brainpoolP384r1_sha3_384_test.json':           "91bdc6d6b1374d688ab0da4be495a8b3ffa5e7834422ce9f27a7256dd9ec1b76488c9a1b3949713784a531a06bd49692b721ecd36f88431b90ea03313f07682a",
+	'ecdsa_brainpoolP512r1_sha3_512_test.json':           "5ddb3f9b65409291a26567ebf28953f788d6dd5f70b0af39153cb7f20e8cd80a23db9c11362bc86a92697f0d9a77903ad528b16fe23b8cfcf310730d71ba24b2",
+	'ecdsa_brainpoolP512r1_sha512_p1363_test.json':           "e5383f4df48561e5ff91fe87c67a0a002b14c4d0fd70f345933acd6bed23f9dce35ec92c4cfc5c7d4be5bab2b64780e2de3c8147e00b8ce9140e4c2b39e587c6",
+	'ecdsa_brainpoolP512r1_sha512_test.json':           "bdacf47247e475e0a259c87b96a77032be653c2fc9489534197a80fc736f16ef0f48f4736c45eafbb875f266a4ef0cfd08f0566d6382ba1abb16ffb4ac741dfc",
+	'ecdsa_secp160k1_sha256_p1363_test.json':           "56b607a6e9faf19e14c27f4f70d64f9786e3c0de50924ad6715bef65bfd5156b1cd401695ca1c3486227a4d3b9de49d81d70900e07169ad36170c38d2e8a53f1",
+	'ecdsa_secp160k1_sha256_test.json':           "e48c03f62d45e39d2572097282574421447953bed47168928b930b32680bd68be5aaf7ef0ac6c7632c7ef3887985f0bc1788167299c42e5cbabe5925fb5eeaa5",
+	'ecdsa_secp160r1_sha256_p1363_test.json':           "0ba341b6a70732017971c0ab38c48b264808bb5aab563bb3c66ef31e685f2491abebe3a3f114d541ac3bcc503b59e7f02e8f35536b9ce781b8f6b9c57c72a731",
+	'ecdsa_secp160r1_sha256_test.json':           "70b593c449b671b3da62d1224a1c7fc372cc34d5a067fb87f70a65d14a236a47121bef499b072acc9ab2c4c70d3a4305c90b89059719ad41dd2473d5fcb7a14b",
+	'ecdsa_secp160r2_sha256_p1363_test.json':           "277067478dd5b6f3d81da3bdd706a68429d7d8b0ad85d3c0843ab7bf022a0857df05ca628c61e92358162e75c4a505fedf7c0c643382279bf6ac47e7cf2864c0",
+	'ecdsa_secp160r2_sha256_test.json':           "2f1b0d917d703e0acdfe863078d46f5dd0a51d9e2fa07b2fa34180aa6ca4b175e6a14f6972b9a2eab3523b5c1d11adacec8c92c969671b379f30ef0b9185ba67",
+	'ecdsa_secp192k1_sha256_p1363_test.json':           "dc703ac1ee295c20df496009c8beaf6b1f1ebf00654c76f335dcd983ce0a19d3e8c2136be3f78ef2294a58b4f953dba53c8da97786064d66ea8e7d85ec77ff0b",
+	'ecdsa_secp192k1_sha256_test.json':           "132c2a1656a03397d1334048be3bf3d4825c6e08096196b8d5d1c11843b4e543f0a8c898bb7812355ea8774a979f749c8b8f9e5062e1d91c22d7220c678f8846",
+	'ecdsa_secp192r1_sha256_p1363_test.json':           "4669db3e1921dacab450e901612cc219ea681941f2b18a0f8c874a018dbccb30edfd421ff167b685180cd6e9ba87c684cb6f0a18d6da467b5f2167fcffc94b5a",
+	'ecdsa_secp192r1_sha256_test.json':           "9d03dc6a28e9e131ec37a2dbcc66b0d7beabd8b8e43af314b2a1bd5b8e731fb4d0706233d17a4a9b5260e638c1c4b5b7e5cd69357eadd1f02ac19f47b82f7cbf",
+	'ecdsa_secp224k1_sha224_p1363_test.json':           "28417835fc6237dea10e8f747b2a12d3276409a1746994771562d66d80374c571408eb27dcf907adde920748dded41b00482a26ba1b1a00b07efa4b6939467e9",
+	'ecdsa_secp224k1_sha224_test.json':           "693254ce147e24c082e913862231c2dec907ef280c95543de17cd22893bb5ba47f5fa0b83854848e583941e60e93bf24d925af26f020e743a6ab6a63e73076b6",
+	'ecdsa_secp224k1_sha256_p1363_test.json':           "971a6632780defc1022a4138b3df8a8335e2b92e91ecf8971404dc4e71a35ac136b2eb1f4d54fa8474bbaff7a67d918a52fb34ab6101cf7d775766d024f06221",
+	'ecdsa_secp224k1_sha256_test.json':           "79b739ae824a532c5eedd62de60ce14e11a7b7f5ad0550bc7f97bea21e2db9492c0b0538edfa170e40493ae6dca0fa9b0f9f7e182c5bb503405b246de3d06c2a",
+	'ecdsa_secp224r1_sha224_p1363_test.json':           "5014189fd6535307640f56df4bb4b11ecc040c95cfde90e8d0da92a55fbd6861257566849b899874106171ed40579981a98f1dfa482b72d021c9dbb409bef254",
+	'ecdsa_secp224r1_sha224_test.json':           "d81458ba50f06d0157e42abb441f12b0be4c409b1430bdee9d6cf8aba2985d596534b606ec17caa3f176d4c2c9a95fea3aa52a3b3dfa136f287c30348f429c5b",
+	'ecdsa_secp224r1_sha256_p1363_test.json':           "7b8e4264ce143ada9ab97576c63000629701e602a94ca47045b750f55876a68b9502ee6d4adcb03533c58bf9cb78b3ef4ae8c91361543dc02d29acc210c3804e",
+	'ecdsa_secp224r1_sha256_test.json':           "6e6aca400c5b5c49a9412aec7263fa75b76577abe19a9decdbe350e580211b9ad08b8a757c74b5674f4d3427f95e452fdac1e8551056c8cc37fc0622be3375ba",
+	'ecdsa_secp224r1_sha3_224_test.json':           "0468c5c71ff3a7a1e8942e570552f718077a54d83e698cffe7635342fe121935358ad70c7c6f8b69bdfc8454204cc3d772367fdb42302262418d867d8683dee8",
+	'ecdsa_secp224r1_sha3_256_test.json':           "e423747bd477797d04b3196b4d1690751e045e737b4030010a3662a584eef0ce213562e8c204883a5b8901a970d2d6a736a740161793f6ca73bb5d8469f95381",
+	'ecdsa_secp224r1_sha3_512_test.json':           "094d0d96b38b87f7060cc28cae6158a0a14092648eab4c85b9e701f5c08e0c9a312a500c452cc0cffdfe46482e5c65ee9973643f3a144902557adca00962d5b4",
+	'ecdsa_secp224r1_sha512_p1363_test.json':           "02c1d323331ad22eb82ddb44d3f29b48285b3cfcfca43d28a2694f912762188f5dbecd968c0bd3ce7a552641e49502db679eba8044c1a0c5fa9c054273384f5c",
+	'ecdsa_secp224r1_sha512_test.json':           "9bd69463d1e24c9a086cddba4323a1eed6fe34ebc6d0b087c5e40d067260bda62c07250bf4ab8069b95eff2826fdf4abadc01f5f34d9c37a218bb0f77625d151",
+	'ecdsa_secp224r1_shake128_p1363_test.json':           "4d675b55466f79ae3308a082b07c3631296ffb947c2cbe8033cb52a3ac3f8a83db484f2f22b4c70d5aa345e1140fcab48ab1067d75e3feb2de260a3bc4ef2baa",
+	'ecdsa_secp224r1_shake128_test.json':           "4b9ea752fce41061c8de045b33127f665d7a53f627c687c82462775f7b2d9e1fc5e531fb3bdf735218a309afa40d4894ac092c2c8620e3ca1c50f300eb26f6d4",
+	'ecdsa_secp256k1_sha256_bitcoin_test.json':           "88f6be4d25f879097e12cfdad377c2d77a20189e4b5effd8ea866092e2477e8b48e51e4ba8ce55332ca223edecb30fea69b3a3d8748976d28aed98869e80cf21",
+	'ecdsa_secp256k1_sha256_p1363_test.json':           "38adcb33ea8cd18ceec78a1c0a7c36d3d8ef47303906751fedea0207f4c3cb1fc57fefc109612c30b61c75b3f9eb91cfb56713a745175d0834841cd660cae327",
+	'ecdsa_secp256k1_sha256_test.json':           "86a211d21b7bd9d6db3e8aa81ad769373f6e18c3fd05c519af217a5a4304c02abc36b70dd306094c7fddfa6489a9c9b5a3e9cedcea28c4081441db1800ff6aec",
+	'ecdsa_secp256k1_sha3_256_test.json':           "7d649655e9a1aa67b6c275e2547a7dbee605ec487ab292f2f1c67fa8881cdeca841a82a8093217c521ec2bba36cc9c6e05c0cdc4ce64679fa6654a68c76c3782",
+	'ecdsa_secp256k1_sha3_512_test.json':           "38e1a39e8aa538f33d4facbef07b9fd9793a95c9c5270c2c41dd9a0da9d2b32cd84dd525fd379de94348794cbd82c8feae1a925b0ff323d260cb01f58eb16f3f",
+	'ecdsa_secp256k1_sha512_p1363_test.json':           "7bfa57b2accc0071db8c849685769eaa0e20c0a35f18469a284d0e27e340a3f7f1198898d5268500b053b60a0e019308a3b9c536a27c95dde581490a5215c438",
+	'ecdsa_secp256k1_sha512_test.json':           "1c1b635cbd9a56e910959f3a4551247d1c8a42930a418cf0fa8a686d6370c8730a274ff56cfa4b3e338c9321fb94ee5adaf76dd30ac312db0c7ce74c0457c55a",
+	'ecdsa_secp256k1_shake128_p1363_test.json':           "ddf80ba820144a9d55775d4ef2ff65117f462943988d0e9be4cdf0dc9a013604d8ad0f638866caa66643f6bb3837480270d528eb4c86ca3233d7b70ac1089e03",
+	'ecdsa_secp256k1_shake128_test.json':           "da83dc544d289622eede109b35c148715e92e36cedf8146b5c5856431302c0bf2696179122e0d4eda54e8cd2447b78d2198c4dd7a1e38ce436a57e6b9298323c",
+	'ecdsa_secp256k1_shake256_p1363_test.json':           "d3b27fadc3e13ce29c285d50b579f0552175bb7af62b7982fabd4185c114da01581bde46652beb0c5374ad6fa63217d85a3686fdfcd8a04ac524f5779c995bee",
+	'ecdsa_secp256k1_shake256_test.json':           "f6a04a4e3706be7c85f5186842c193b030d4e4f7359c71e8b3ce3d78f33b62513f68e76aa841caef9c2de4140755cc5227572bab1d5c978b1585036b2c08d4e3",
+	'ecdsa_secp256r1_sha256_p1363_test.json':           "b69438a1c52b7848c14d42b5497864e028a00ab2b6bd9535c7ccdda8250a71d4fa6aa8efa133de9d04b2f7e8d4e882955dda5b818a87748a6c42e105deb7a9d7",
+	'ecdsa_secp256r1_sha256_test.json':           "f3bf0aa82757e24bc0a7ff310d070b41beed993fd6ca83712761a398914783c86d76f4a4aad5bac678f980425ce5f4c1cab05c48de5fdaa22261682789ede7b5",
+	'ecdsa_secp256r1_sha3_256_test.json':           "c95bd5bf590fec6e7e942dde5ef9736cdaa1f4751bb7ef3898e4cd36fba2f27425ca59d239e653cba9757f531e9ba057966d016f30a0b569b24bd5190cdabbc4",
+	'ecdsa_secp256r1_sha3_512_test.json':           "3f77e25e3d2c0a9ad73d67ed499adce02b98521acb1bcf4b51c8fda545e849bdca0625789ad635846e1691a175101f6749e0c3885f657e8dd34eb416e3935fe0",
+	'ecdsa_secp256r1_sha512_p1363_test.json':           "4f0e573b4f56cf770cc64e552b86aeee9503a65aa51f6e6faafef5b81646fa773be21b0bdd0e055bfd607c81dc07ad813860461e3bedde9b7b31be33c16d2f71",
+	'ecdsa_secp256r1_sha512_test.json':           "542bfa5f83b4a44b497859e114f4d326548743d7955ce627fa8583af1ab704f5ba4e219a87154e41bc43cd4896d375070e95b2f76f5292a28ab6947b92d79254",
+	'ecdsa_secp256r1_shake128_p1363_test.json':           "91d7684cdf93f62aadcbbceab1f925d0fe383081f99232a6894235c662bfbab7142f097593c290e6a2fd6528d5ba6db9c1a0960f81e5481c89e99a27bee19a1b",
+	'ecdsa_secp256r1_shake128_test.json':           "5a42bb44f2e5a1671a584110f1664806050ad644631e6f1a67ed3beb6c788e5ba8e9e4933e58a11ddad2006d86d4ab02795b6d58236df15e92d4b268ea995336",
+	'ecdsa_secp384r1_sha256_test.json':           "b19291081e85e8d5411c01feafa3cd75abfea1e81a12ad90ea5f8d54f0c116c1e79b79be9175e8c9ada21aef5826349e417a0ef93a092339c42562b6192c137f",
+	'ecdsa_secp384r1_sha384_p1363_test.json':           "fe2204047f88ae726ed5188916110296e59930787b5db8b243cc296b96e449b6e4336ca16c20ef464add1a7712d8775aa9eb149e2460b56ebd73d674ef115984",
+	'ecdsa_secp384r1_sha384_test.json':           "b34934d80b603f5f1c56eeb341015f91e36ace086479aa677e7e32f5cecc5e25d6e2b8e5901968d9c041173bd828e23e06fa264f1ec5d8c7a242b3bdc7dd060f",
+	'ecdsa_secp384r1_sha3_384_test.json':           "146a5ff3d62dd4a8a75822e435c55913b7b9c8e40fb93447e65c11471034068783dfe4e5af600280a367988aa1b4b73212d98da6e3f720741b03011829afcda0",
+	'ecdsa_secp384r1_sha3_512_test.json':           "514de7b81e7b466adc3e255583543eb039d9a9254ce112df48509bae2819d77ab828ead9072484f699c7c0343a6688ec69c1764c3a90b15b4d83c23c99649a95",
+	'ecdsa_secp384r1_sha512_p1363_test.json':           "1e199e57c2c9529e9b719c63791387b0ce58977603853e10a6ebc77b1a8bae38977d6149a5b9ec8a2d34e99aa6be96c0fefae141250410018d0ccc9241bf46f7",
+	'ecdsa_secp384r1_sha512_test.json':           "e168ce7aa71cb3456a412ba4dcf370ec0d85b683e588e3aaf43e400a374f848fc508c8a6cccf667e64aa6db5811d7bf7614dbb6b20feee0bab410236c730516b",
+	'ecdsa_secp384r1_shake256_p1363_test.json':           "9c1e9d8f2366c8a166754bb5966829b97bcf7ce24a138df5af98a5f9b9d1cabd8fcaa5588600fe550362b3a43a0eab01b8d240020bbfffeda1b3cf3954c79709",
+	'ecdsa_secp384r1_shake256_test.json':           "216fc6a38b2cd11c72dbca9a0c91033bfcd08b9d644d2890aabc56f75993928b1d1be42f9d2e516b8e7f91a76c7284ee9a0a7e3cd3a72a2724cfe262021f88b3",
+	'ecdsa_secp521r1_sha3_512_test.json':           "1d22bd1409174eca101e466bd145b72d24f7d0a3581b748517d7bf715534f6d785cbaf1c5f3f8c340cc3e3577c23e7e34cb0051d6e45690225e0e91cdcf4ab3d",
+	'ecdsa_secp521r1_sha512_p1363_test.json':           "d69715e60aecc95138071d9d1f3465aa37a98cd8b2d5eb3a7e49a8dd5a9dcd96ff04e61e45eed576eb391aa4eaec48381cd497b85588a11b2f6d6db5222b2eb9",
+	'ecdsa_secp521r1_sha512_test.json':           "1014452d732f9a33b6acf340a6fd6ad37457059ce97b0e1c3b2f0f6f39bcf2590cbad459a201571da14305b02fcc847c756afd389cd76103fd99ed973dec693c",
+	'ecdsa_secp521r1_shake256_p1363_test.json':           "b3aa4a85832cdba635d0b55204e71612af4055ab6eccbff575a16ae9645dd8b70da988c8e176ea9f951c157b48c92f04594e9d61a56eeebbf87b80066ad2ab26",
+	'ecdsa_secp521r1_shake256_test.json':           "26a3cdc7a24e31efd1d5a6818617d6b68865c04b1ecae8214805b1440d0b691564bb0042cce9635fbdc8d3ef6536a175cd6feea883fdd4bc44cabb07f0486a8a",
+	'ec_prime_order_curves_test.json':           "e736e7353d810e499290d340ac922faa7f1906018279f3127f4383265f6fbe97f84b4c334b20807666a20608bdb6182ab289cef4ddbf192fbc2a2f49d3e71e73",
+	'ed25519_test.json':           "c3429b58132268803f3766b686a2e15ef52d9e59a3b1d0462c9d8c2ece0ae8d6d9b41d051ab37ea72388519bab78312500ea7e2052b7fce00271c2a86adf9645",
+	'ed448_test.json':           "63d02608e45125f3b9e72235a465cc4b050e30ac9914befb17f2cd0478791cef2fb5ac5c36773b836b51c1dac3ce3688b90f69e8dd3a404388cc18379ba447be",
+	'hkdf_sha1_test.json':           "037187bfb616b1938eb11a0b9afcc0152aa806d9fe1dd944d2524660a9d2c6474059d38265e838de0677bb6b993ab40e1a6ad18c70ca0efaf1cbefde7bfe588c",
+	'hkdf_sha256_test.json':           "b8d9854b418d79a265b890aec7436f9a6856bed22d7a31506699874e0505b251f5547cf064f9960f56c955a0f95f73ce39011a3ac9e2787a9beb3f5049b3414a",
+	'hkdf_sha384_test.json':           "424ca85042c09305ff0ff7c1c95ae8bc621a135ff28da42792ea8ec7758d4d3d096fb4a9c01dac8a0359717a4e1f043ff28992e7b19f5d6b2fd4c13e4a5dd0c0",
+	'hkdf_sha512_test.json':           "ad0988cd4d049284694686c32f350c39ea18c20c4b926d0b5653432d463e3183847387e37fd612cd65376301fad9b8755dc1de577262715adf46869321ebc97a",
+	'hmac_sha1_test.json':           "b99d895f358207ebca2d9109162d848d94b32ea4eeb71a7a5b10841695020bd2656c9f413b2d42b3fa1926a7edc6330f240d55463e674942e0dfe17ee37116fa",
+	'hmac_sha224_test.json':           "c3e3d603df286caa065111875550b6713a5e35b7756aafd491b537b5330304293005f62ed535e30ab5f8970803b85e8f1436a6ac4c0d49db33550804cb0b5185",
+	'hmac_sha256_test.json':           "f763fb3cc36280c67abde9d8cd7182e4762d4eb27708e213dd09f37ef4a88b371169f4b8675b0c4a6ec72fabc6c07823ec9c05e51a36c24eb408e71526123ea4",
+	'hmac_sha384_test.json':           "c263583f6775713024323e3b2d0ad5f7da811476b002bc835131b5d36f86d9a1271309a2fb06371b451ef08ff65380188fcec4508f829c61d75b25518d03d631",
+	'hmac_sha3_224_test.json':           "96b3e8b2f1687256c29d781f413eae5566b9769289f78b93676d57ab224cd2e70ff03f1ffefeb6fe5877b75d92609d5dcb6e5ca7331e24d12c3f88f25577890d",
+	'hmac_sha3_256_test.json':           "ed3d16591015756c72ff09823d87dc36221fbc483190387f129816653b9c96d8797d134e50ad7765197913b04a60a301418f12040b55c51947ca75f0392af745",
+	'hmac_sha3_384_test.json':           "5bb6387eabfb602060f4e2a7483111a83e0be37d5507b443c5f484ef91c717d2b5af71d8316eada168ebe81a47c0d399e503050928093f424000f92899c73d95",
+	'hmac_sha3_512_test.json':           "b40c162f68e2878b39c8ee15a7cb381f99e2103346b115d73830cd15531f19c6d607a0327d78cca46788db37e2936b1bcade6739515e951e7e0e79e38e51f7f1",
+	'hmac_sha512_224_test.json':           "88278c017075ff186dce6aa9a3500cb40a2053cef4bae8ff634aabce422125a199909f50f2dcbdc213098307c8a81fee9efce193d909de213b7342955c411a32",
+	'hmac_sha512_256_test.json':           "eec3fa84e6bb73505f9e4e76f06443ed6d6c4874fd495f3bc038a04c56e74c5b8e070542c2360a7db383468e15e9479413665113fd7fd10001f77cbaf528f468",
+	'hmac_sha512_test.json':           "47a25df89a8030c5f9845fadfee5e22fb17902488f85f32e90eed2d87b4251c78b1c98494a1a563d89c52a9312c06f13fdecff6f4db6fa191a47fe5cd887165a",
+	'hmac_sm3_test.json':           "d3299c5d21c99f2f9da28ee4e348fac2c5fbd69f23f224db74f77db1972f4a2a6813c00cea22a9472cc5a2944b3560a44320eb11b4a6a66a930f5c614cb424f6",
+	'json_web_crypto_test.json':           "6e7f5c6218b460255560f547bd5f730e9be43d64702f1f42bfbda74eb8b043f9da51a0c8569b5433305793aa6942bbb8af3f83ee33e5677b0adcce911dc2c9bc",
+	'json_web_encryption_test.json':           "ba8f4ce4c48102e32662e655ccace79ab6413be8c6292df85c7be32978892f5e280ecbb23c2f5bebbf18d2581458e2ddcf0d38a92513a4482f779b28da0a80a7",
+	'json_web_key_test.json':           "35ce8c596fdede766bbf60bcf3cd2be5e8cc2a874fb5545722374817234da3a4dd2e5462645dbbddd7ca346884c5c9064e13ee12eb57dd013c87874e029c24af",
+	'json_web_signature_test.json':           "f57e6dd1ec52fe8f4412a5622310813d44c2c5b0ecc12c58ec68527fe433b4d4096a314319aee90b981a0a350676f186a25ca059fc35ed6ead30b3b6dfe20677",
+	'kmac128_no_customization_test.json':           "f746e985e40d65cb05f16b27dcb89749cc8aa8789a1eb298acd27bab186c5c4e2214806b1b31cb4eedb7bd9fbec5c58cf506988e1838d36d3489d4b46890f35d",
+	'kmac256_no_customization_test.json':           "93c31894cbe055881484ee79da9b64f79314d91edcf139c58395c7550ea92ff0fb8928b583f9967da850e01abcc49f651f78d10732cc67f0791cd9cd4fab4d3b",
+	'LICENSE':           "8cf5c2279c45d0b1215be0b06a332782695ffaa810f93ee90a60c9aba8694dcb5ae798ea8e58743b82e60f134db0e2d91fd9c5ccb29417150368ab61c6f0af60",
+	'mldsa_44_sign_noseed_test.json':           "5e06e259dd15cde1ce7fd724ed22e15701e772f7a7e14aece0917b03862cec5a9302111adcf2f7e9d3e6e87ff50dcd577c1d3acbb8924dc0287a33861cd3c7bf",
+	'mldsa_44_sign_seed_test.json':           "fbbd614f6550b55da045eb28f6e91db41e9f184d8c79de5b8eb83e61641a916c8fe530a96ca3bdb48eabd4748c682d95f4652e4e3b02a538f7b0eefd01cffa1f",
+	'mldsa_44_verify_test.json':           "0d883abc079a4a984407f339ff2eb0e8d98ab640e00fb92c941d1179ed9e36a5835572dd2a6fa8a998f60a253b7253b5ae27b7f12bc461cdd4a2e1c3dc08fa69",
+	'mldsa_65_sign_noseed_test.json':           "c189879c24a3e30df55c987ae902499a582d00514e1e512b421ef1a1f1615c651bbd7e58c12c6fb2f59c3c918170c1d6f04511fbd13b78fad1df422f14f6ca0a",
+	'mldsa_65_sign_seed_test.json':           "459251fd096b4c93f2ae7dfcc99464da1704ed969a9c929a6b48a1e8ee709bee77b2d275b3333278a52d881011ed4d7af129f92dc94f4d2a37a34a369c0fd717",
+	'mldsa_65_verify_test.json':           "6e34eec8e7604e77d18d23e418089ddc2b650d44584e62a57ec9353ce0a305933ef34a1a60f196e5d1ce190241800e74a10a94ce93818170bc2144cce8ff929c",
+	'mldsa_87_sign_noseed_test.json':           "82ea848426d521804cddffd8cb9a9ec1834a039e2363111fb5996ce3a82709670119dc5ef55f18e4e0b65896d054176c69fa555133d629f6bb2a75cfedf4be27",
+	'mldsa_87_sign_seed_test.json':           "aeef0e74488b1b0625853fa87b9f1021180352d674203bdfa505f1ad40322ec8a30a8545405c3a5a8976c77375220fd434e3fb7f20b895271bb4695029dfe850",
+	'mldsa_87_verify_test.json':           "e0fdbdb42b5936a92fe9c0a61ecfda7d10e78f991b66b6a9c3a1409cccbe544023444a8db338086ed8015bf0078f7f7769bc244a404ba2473c54be9b5f5018be",
+	'mlkem_1024_encaps_test.json':           "40e081ea7406909aeb38b4ecf7469c546036d15a1f7d3709420fefafbea2895ba1eddf6e568b220507bb1888047e8c8f1729d34252ffbeed056f6f17d996c05e",
+	'mlkem_1024_keygen_seed_test.json':           "fb401e343275356717a7a0ee6d6f2d9c68ebb5ed16726c25daf42aab88cab4daad51ae025b9fb5483e7582d70cc7e3c0167968d351f8a8a386e2b54eeed18f9d",
+	'mlkem_1024_semi_expanded_decaps_test.json':           "75b300e5a60151b46469c6aaaf24910db60bd463cec418fb699fcdb45ecb01bbf8febfc66c7e725073564934435d3a4e6f79ce0f1cb7e6bb96e5b94c8b7e28ad",
+	'mlkem_1024_test.json':           "610ccae8443178f81dbf3e73d53710daf9935a6179cf19208c5083a9def2bf37e99988822bba2956e9fd8bcaf5947b3ab0636272c1798c9ca2fc734d74a568a8",
+	'mlkem_512_encaps_test.json':           "c1a658f023b982063868f0bf8c3d7b63f7835d8312c07d92f35eadc8010fc48bed541d95903275cfc9d77199e375c7aed2ef6f79e256e5da0361bc289d9dff68",
+	'mlkem_512_keygen_seed_test.json':           "7b69a209c5489bd99b5b4c18af14a1a1c23d4e6d92c7ad9ca159043a80a28095114bd6411c20676fc377a516562c17e11559d4859dc8f2a6e3a0d15347199226",
+	'mlkem_512_semi_expanded_decaps_test.json':           "aa7005a88e19fa6e32235324774fd1b4511fa6c5d57c661258d9aaa259b74138b02b5ab6bf5caaa73282279ace6952896c0e501b274172742ad65a488d842498",
+	'mlkem_512_test.json':           "69b6ac80f6e9a342177ccfcd89cf9e63859319e8e00239789f694bd1d66232bb983acd738d4b09220f595e703ceb515901fa683d3740ad6a3fdfff05478a31b5",
+	'mlkem_768_encaps_test.json':           "fa4bf9229ea60af13175c37f729d59cdcb6429e489b75d4f63e892f57f4e6e03533f2e2e0d7e019f4822ed16b0aed453490558a836a64e1a6c1a821853f33677",
+	'mlkem_768_keygen_seed_test.json':           "238d5a7e0d7177df2976e8ea0ceb5261caaf02966cd6b0cb828567678b13b6daf2f73fa48eab6b8597b1e4b237f40d82e0c2411d834d156f852a128852d6dd27",
+	'mlkem_768_semi_expanded_decaps_test.json':           "34472ce67ee1bf722e887baf6aa64510dd89b71cd58b98abf19dbb63993a8a40800fcbdffae1eef6993390a8a96ad082fe82bd241520bfb9ea62393a40d95bf9",
+	'mlkem_768_test.json':           "33c51ac42f702b0d8258184fbd7b8716e2cce53efcf19a408596f1b406c2fdbd4b80e638e869289794253264ad29c253b0bb57f10471dcee911e6b5a36949cca",
+	'morus1280_test.json':           "1bd1c271807b26e06cf33b7f50de1c7406efa38dd91966838400e296076451f1dd3ada4308098aa185b3962a91be3286d62344472305472def5fe0aefd5b5695",
+	'morus640_test.json':           "2619a079189ca8c4ad79071a80f9cb0dc5af4330b25490b03432af12997be48b046cd6949a1dc4f76ca1d93159d2b0229de89ce1bf19055a47e38a06789cd05d",
+	'pbes2_hmacsha1_aes_128_test.json':           "4dcd8511a36a39cf8ebf36dfc921c1bbb79b0d5dff179dddd2a37ed79b58bb8f45aa1bcb3fd7a02024580458df1813c7d1c87a63df46c9285ba99c3318d479fc",
+	'pbes2_hmacsha1_aes_192_test.json':           "65e072bc0faea0d0ef649c1eaf82984a241a139d91414b636679c661f4539c16aa4e9ba3852ea22e42da366450507fc3c1ee61b0c78263a59897de1b003617dd",
+	'pbes2_hmacsha1_aes_256_test.json':           "8a56690029fa28e8df80bb5a95389a72d1c5d23fb76ccadeb767f3e40cf2b06fa7506e7a01abe63912c13bc94123aba540aa0e0c92a43b8e6dc48ca972b5ab72",
+	'pbes2_hmacsha224_aes_128_test.json':           "98a5c1f874d4e85c964d23be4c46ead32f157c6231002ae0b9aa03b1a4d7833fee2719715ecae31ecd4265b44237beb409fcda197422cb6d25ef3bfce88d55a3",
+	'pbes2_hmacsha224_aes_192_test.json':           "f3e099e0e0f8fc8b3bfe3a6c67b28c54567f50d2d35fc845e7cc34d6c7366eaa78a48074290714a01213faf57407eb24a3b2d614823d49458dd63d4900aa0e45",
+	'pbes2_hmacsha224_aes_256_test.json':           "fb149363b319dfff8bd9b44453f62620af662e7e59d12e37d01c65c1504f0ab076414c475634525d6549f362da208e6dc1c0f445a92d1020af4d020b29d8f04d",
+	'pbes2_hmacsha256_aes_128_test.json':           "9791d10cac4cfe6aa13e955d9a1f606231455d27b13a48184eedd1cec587b4c20fec516a969b8fe82de1ed6e653d325b1d230c926e0365230e8321a535fff164",
+	'pbes2_hmacsha256_aes_192_test.json':           "ee31846af4512fc081c2a520a6900abfe70488341ed3b94c591dd65ebbf75c806b2d362b6d3aea04985a7b55515da07e52208aff5684be4108a0a40a5444223b",
+	'pbes2_hmacsha256_aes_256_test.json':           "3319746609c74a8678e2c02393da33b7b8e4f5cc9f122a79aced3d3f829d12368fd667d273b90ea3be3abf27eaf12b3ff7034f5a2c124b647d2ade0709212d65",
+	'pbes2_hmacsha384_aes_128_test.json':           "4734268d3045cd6c1c3d001152bceb91045ca367e998e94c2b8123bae1c0bc6e40a646b05566ebb8e27ff21c07f96a2d34b71b29cf7ba47a41af1327a12a0817",
+	'pbes2_hmacsha384_aes_192_test.json':           "5c415d4a16b3b0646ef2e288ce230fde3b41016b3d2ffdd42f1dab576c519087ba89cbe087abd1dc6841ed3e86e87f8e0896ccc55fb37aa4d8b91dde47e97612",
+	'pbes2_hmacsha384_aes_256_test.json':           "7499b1e8faa06f155dedd282d49baaf1c3103d92a90d9fd9ea9d43342ee7f037cd61ec6db11c758eefc8a2ab37aaac0c0cad946979dd90d89b0cab05c3e2e4f5",
+	'pbes2_hmacsha512_aes_128_test.json':           "ae7a8419b4080d1edcf051791dd162b21fbbde87671c692042d090fa7b0a3a50e740ad1ff600efe16b669e29a0a8cc76c70168ac595fddfa15358f44ffed2b43",
+	'pbes2_hmacsha512_aes_192_test.json':           "018312ddd664d54d1f61887c5b2eca6c53445ad687c541a112f4e01214f4bdfca3c1c040a4f58073e25bab81f9cc16594b325126ed094f25947d6736cf2dae68",
+	'pbes2_hmacsha512_aes_256_test.json':           "88a6744e681e932bc88cba92707dd4175d7628b28722650e583bb88996a4359cd3bfd9bf6e7d7251bacb6f6ec3f373c89a8726a7941b0fddf80950ae3853be29",
+	'pbkdf2_hmacsha1_test.json':           "ef7f30803bb875100f03243a4ecdaa828c931727d987b02ccdf5e11c016a9d39b701a104f139249070c0c9608bfa21094f12c1288a154146a4d5d445d6a414d4",
+	'pbkdf2_hmacsha224_test.json':           "c76b458adb68d4298d4488c9298e22660b88d339663bd916d4a4dca16a6c45b3deece24670f93822893fd82f1ed4fcd83320a2bd17dbd01eab4b6bd424f421c1",
+	'pbkdf2_hmacsha256_test.json':           "68266130cf691a7de55812ffe8467c5af0d925dd7e51a1bf7bf37920dfabb63ebbf4d63e7726c6e7c0d62267391d73225af3788d63c2aa4108d34d53ebb774b2",
+	'pbkdf2_hmacsha384_test.json':           "7258ded76df3f3afa2ae644fabb61ca31e2adff87a3dfb7735ffa269fdc4c84154c561292a1bcf0a604e8757390243cab30b021b65bef0a61ee368dfc0c340f3",
+	'pbkdf2_hmacsha512_test.json':           "acf31741f9fd073b2de96fcc054d2740b05a72d5bf28e96238bf7eaf74e036ebf1920bfa97060b572ea625ed243d62e6586f31a6e6fe79a18d7e82cc677283fd",
+	'primality_test.json':           "f67b59682c44c867b39ad8de4db11ae3cec54903d3ae5664665d0176c09d6247a9a759e3ddaf74557a0d463aef33e096c3c3bafb0d86ec9e84a42372d47be228",
+	'rsa_oaep_2048_sha1_mgf1sha1_test.json':           "11b5bdfe2e8b182188f5afc85ba9f2a90805f47f9160e9a7a09e7cbacbd09dcd50034b64cf4586f3c1dc8a5740f6961a654849f33e83843a243a8db90320efed",
+	'rsa_oaep_2048_sha224_mgf1sha1_test.json':           "25d839c8e212bc5c4edb42ffe782e7047d96720a5de72939e2a1ade18c6a1b7fc65aea03568c6343dd193e97c3220232c6a2ad482bd553a87a9c10f5391690a2",
+	'rsa_oaep_2048_sha224_mgf1sha224_test.json':           "ee36d3b23f5b30e6e2b53de9f96eb21642011dbe43082ea68f6f367e640ad278f6fb315d0159f6cfa9dfb7d65ffff3934ef97c80f83f6732dc8542afee373cc6",
+	'rsa_oaep_2048_sha256_mgf1sha1_test.json':           "afc711f13ff6e5b34630031fbc302eece309f132e3d31310cd43ef05f36605bc3a006a12412bca8ddff984fa358656a4a2666f2e1fcd0d6669a7be5b4c225adf",
+	'rsa_oaep_2048_sha256_mgf1sha256_test.json':           "3830a5ed60d6234996dd8fa336e7973c371ad5d6a3916d6e641e8bb2d1fce620db0aa68ad2a46747970a49d4215c09d649bb70fb0b67bc497c5e2c332c2bdc38",
+	'rsa_oaep_2048_sha384_mgf1sha1_test.json':           "8cffeb10a6b0ad360d0cb9fc598d6dbfe3e36ce905b2e5e11548b487b12cfbd962799bc58f31b106b1d4609ab7e36d1c4dda081a9f7b4c121b9c718b1ccffc96",
+	'rsa_oaep_2048_sha384_mgf1sha384_test.json':           "3b4295e01d8ecc5f3977639d6e83926bbeb718a5539223840eba3509f65ca03812ae704edc82b7b6b78322ce013ddc9e7f4c877b9609afdc4f50bd39ee59f5d2",
+	'rsa_oaep_2048_sha512_224_mgf1sha1_test.json':           "a2692a73b9f7106a6187fbee744bc95700afae8726c214b9e010f587df17cc7e15ee3a650335646c066311e948862d68b427d791f134f74acaab3af8684609c2",
+	'rsa_oaep_2048_sha512_224_mgf1sha512_224_test.json':           "fddfe64945f4658eaf2e2ab37dbc57684eb41374ab76634c74a9944612e0e12f18a31d82b45d47a106a5a48ff0cf5656248b09fdb05c45b8c9f8510b30e59d55",
+	'rsa_oaep_2048_sha512_mgf1sha1_test.json':           "06b6d80b295d82c298e7017a748ef40de6a2d7158d6720fbcf939d8402e1219e657dc78486b6a51f74ed5c1a24a8d9bae33a9a752afb86b68ac2a657734eae4f",
+	'rsa_oaep_2048_sha512_mgf1sha512_test.json':           "5f66c09045781395b6b0d0f34f6ed5a6a794536c6883f2e198c24ea4d2cb6fef12d96e5551ef36e9a6c09b3a5b97809a1d9d996072c65e9dbdf28690ee1f10ba",
+	'rsa_oaep_3072_sha256_mgf1sha1_test.json':           "6202abfba2b997f3d3f7601317bba95938230078a2edd4012ebf353169975ed788f273c841c18ed88399c167a2d089b383c0f16de6777cfa68c2d131e967a7ca",
+	'rsa_oaep_3072_sha256_mgf1sha256_test.json':           "893470dd1ae0fc4d943eae9f2f7bb3518ed2e075cae7817962e75e0892540ffc40c6a1eae937f0a4fa8bf26a0a0ff59b08842c30e02813dbaff32a8c7c16eaa4",
+	'rsa_oaep_3072_sha512_256_mgf1sha1_test.json':           "e8a98b51883b223923daf500ac36d97b727e146c877d37e70ded077e2158c320535ee9fa06faefc4139b87288def292b95738a20cbada659dc32b113f7688a68",
+	'rsa_oaep_3072_sha512_256_mgf1sha512_256_test.json':           "8553b7ae98101c4f01f916e4523684611ef03f94ffa069ad4361cad6f7e0603a1d7327488b5aa60c7a85f044228f97b7396e318014d274028c62f74e6faf5ae3",
+	'rsa_oaep_3072_sha512_mgf1sha1_test.json':           "6373311f8465bb8b93086a2fee08e80221b26fec6727e2e758f54645a7ec19642c5d16340d581cdecf0e90bb34d13412e8e3a3c020b6fbcb3fbb3263a5a025e2",
+	'rsa_oaep_3072_sha512_mgf1sha512_test.json':           "16e04b37123ef54cfac757e5654176f90a9b085ea822116221edbd3ad5afc7d8352dc4c18f4d60abdca6ba0d050872f5f9bcddbb45862839c998876e746cc800",
+	'rsa_oaep_4096_sha256_mgf1sha1_test.json':           "48ea4b20873c1bea93bb9e322ef038d805000b1d54a24f387f825c42544c204bd2a4ae2e7bf6c368443505611e9fb5ab0d524461dc94e4432c0016a450f88762",
+	'rsa_oaep_4096_sha256_mgf1sha256_test.json':           "b490d0aea765ae739715a91f4adccd6ab75822eeea2aa77ea25961a5b11208b77b20a445d6cd5833fb4a384bf490a3f37472492219e7d638f2101757529e555c",
+	'rsa_oaep_4096_sha512_mgf1sha1_test.json':           "b9849c95be878f3b5b1831f42c45a56d8a46b92e2b187dee3f2be87c376a5c3d4e9fd3c6f0242ebbc2944c62740f56aca21b508a19c8d1915cffb91deb82292c",
+	'rsa_oaep_4096_sha512_mgf1sha512_test.json':           "3d6dfcf28380a6395fa7908344e5e2bc6bdfadbebc64fe1d11fa2d519bfbd78f603f27a36e5310d4e76ebe7378d90f5965870ea2a542d966e58717f149410f4e",
+	'rsa_oaep_misc_test.json':           "c6b1b8563ee47e4079c8f1273242021fc61a2190b7f8d9d4facecff8905164235b28e64490bba35cdc2a80eaafc7a92f1d1c367f2e26bfee7b7318e03ee25f7a",
+	'rsa_pkcs1_1024_sig_gen_test.json':           "41f2989c6508e330f57c94fa336873734c90ce608e9bb884bdc58232db230dbd1ef10740ccbde8ce5d60251a307d9b47a9bc3d255f7775565fb3d38f72867186",
+	'rsa_pkcs1_1536_sig_gen_test.json':           "94aacc899097a50d0cdf361b36e7c8d94bdd115bcf9e8eb03fee0fdaf4380576ff9922f3d382208661234f3d515d763e7dfabce2aa50010dbda311cd37061a00",
+	'rsa_pkcs1_2048_sig_gen_test.json':           "94b8e6c8c215d66f467fc2b475982be0743fd7f9018277eaeddf231a34a1ef9fdf55b13d512ab15a6a0da1905e6c4b08fd2866b9953a2cd1f9712d5a7c06aa01",
+	'rsa_pkcs1_2048_test.json':           "e4afbe133355c2a726d4f2c5fefd4dfbd3318c6b337be32af129eaf0af4bab233c83f9314332cab919327a6d76a1819f15e6a0a33484fa11cfa4b9315a2ce50f",
+	'rsa_pkcs1_3072_sig_gen_test.json':           "662d1d04eb6ed436ea1eef20cf9ba05ed45aed7e45266e847f2fcd999bddfd465458ec352fe2355d806ce7b347324b3d8a13b74dabd37aa88989368926a4cbfe",
+	'rsa_pkcs1_3072_test.json':           "7164db87ed34cbc0dddfbddb3e1449b569ed48a9c53dd76f2c64cf38101c8c5d54bf1244c37ac0d94b7d11c1cc31fc7c76cc1d85801355bcc9a7eee17e95e0db",
+	'rsa_pkcs1_4096_sig_gen_test.json':           "709437bdd819439ea8c354bf15d894ef10b07db1da159e14b1d35d4a1c4c47e5d7b67e39d11be8b2b012517eacb609596939f652a78670ebaae12242f4958f3a",
+	'rsa_pkcs1_4096_test.json':           "e36e0d26558ea8f7b5f640d4b18cb6d2cd9758b5dacda1fe28f91032f6015ee8e03cf49d59e9c6d41eac691c37e330db862412e7fd7221f4c580f5aa7e452fa7",
+	'rsa_pss_2048_sha1_mgf1_20_params_test.json':           "cdbcefd215211d7dde12fc7c27de31cb2b771fb34f6a171ae902336525241e4685eba6150a773e669e845a7e8269b65ecd7e8e46e7350715abe838330cea2088",
+	'rsa_pss_2048_sha1_mgf1_20_test.json':           "e6469899ca6bc76ef2073a43b94ed3884aa76a3d9cba3cd49c32bf5ec0ca5e1a08c457fd4cd61a4d67dc837402024be37fa32338fb91261b9ebb0e81f6d73af9",
+	'rsa_pss_2048_sha256_mgf1sha1_20_test.json':           "fea4d48e541a65a1afd222f333961f78aa7bdc360cc702fce35d09a92f637103483e1bbae5d0c52de25fa19c979984803f82e22c29aa6ec5530611ed325a4196",
+	'rsa_pss_2048_sha256_mgf1_0_params_test.json':           "f5a8830bbaf9bb72f1e4efc695e8a34efcfe498f4602c0ea254f346c1ce8c278c33c3fdff2cc4a3c041100ef89aa675f57573df2a5c3a538dd367e6bbed6a3a1",
+	'rsa_pss_2048_sha256_mgf1_0_test.json':           "c847a70a03ba42f1e114fcc3f721d7aedd9dda5d4b792e617a329432da7a6c38f2e5910ee9477dafda0780a8a829de5d7a549e08ca4abdacfe3b801dd05f98d0",
+	'rsa_pss_2048_sha256_mgf1_32_params_test.json':           "833fbb7b9259401df2308eade2cb3d1351caee834c1cf68c8d51f152a049cbc31638e2c00d5c74ef85109f048b83ecba0d45d5ecbeeb342f496dd2aad0df2da6",
+	'rsa_pss_2048_sha256_mgf1_32_test.json':           "7baf1f5ddaffcd00f61cffb0c51ab65d4d2e1264609f1fcadf6d1f291b352c05b308ceb1e4cf9a7b8579858f816b47fe74220c9f8efddfdebfd8d2e2bfce8ca8",
+	'rsa_pss_2048_sha384_mgf1_48_test.json':           "b883cf86afc1a4b3ca926bea1279b5176926290c14e5e035c2d8f7cb5d3515b2077edec725ed2706c0f354f1fbe58ed3c850dab1969b6a52ceb8c56e3d0f5e5c",
+	'rsa_pss_2048_sha512_224_mgf1_28_test.json':           "d7aee7bcfabf5f9e2840ce29f56e7bb9674020a965c2825068caa7ed4ef2c0bf6b3f363530148f52081df339a954b62dd037a889980bd5b6db79f812fff921b5",
+	'rsa_pss_2048_sha512_256_mgf1_32_test.json':           "87b67c07d2246381774d8655ba55800cf1df881111e322312fb91f4c0138d70945bb664790ca9c8c29f267974d2d9278c7172aa22115760c9580e3bf13cd332b",
+	'rsa_pss_2048_sha512_mgf1sha256_32_params_test.json':           "84cc291697b82aad164b1cb39dd1a827355f962df606097f528d1c1fc55c9c965d56976c1eecfc83b04ffa7377fcb8ff5c59bef5d213b95a9f1791fa40a35eae",
+	'rsa_pss_2048_shake128_test.json':           "87e89755102a90496314e7daf254071486c222d3880b6dbf9f0600cc5325b96f0a405de46bcf4424605799fccb24414a929f0200fb9e98103cb273c10a406cc3",
+	'rsa_pss_2048_shake256_test.json':           "ac0ed3c4beb5ce6c3ece709bfc28a5ac8d189b622f59ee3920d6eb30f862b03128003b15fb814c05400570deafa8e91dcc6781dee424b9cc0615fa2a5b020082",
+	'rsa_pss_3072_sha256_mgf1_32_params_test.json':           "a15a20bc37a2090bfd47382510e8fda94e32819bab8b1f1c2a797786968845f1c840038e8852fdbaae5bb003e519acfbc5059913925fd4a6f4a2a386dfaea536",
+	'rsa_pss_3072_sha256_mgf1_32_test.json':           "308cf529b12f39e97b2ec10dacecdc06eace7a94dbec1f1aefac717a7da6d43375c9273b400ff3fdc392bd136920943012c3917069d0c4e99215202a4be70f9f",
+	'rsa_pss_3072_shake128_test.json':           "6417d966ddfb9e0862bcc9b02ab967421ff7aad2d2b13011cca1070c3281b5109a0c6ce1dd6ac0aa6e5ece4be5d2ce91bd40508403dd10a0dfe9268df937705e",
+	'rsa_pss_3072_shake256_test.json':           "ead39cf4877b98a79583ade599c7e0e118d3dd69ec6c82ef1590122f3621f6cf0f6d569df3d58c6bbe086102889feb685f964554aed2defd3f05639184231cc6",
+	'rsa_pss_4096_sha256_mgf1_32_test.json':           "1812b9988cb867f67bd975f940560751bd7317279bc6a08769b6060c453ce464ce420c6c5fdbb02df90e036ed3474b8f052eaf351c67cab0a21f911f156c69d2",
+	'rsa_pss_4096_sha384_mgf1_48_test.json':           "edcf2757d25e8824a33bf64fcc8622071ef510cd4ef21878002cb3b79c88d69a03e77dfa73d083cbdc62e8eb7accc12fcea447c9c2a805bac2492e7df7dea615",
+	'rsa_pss_4096_sha512_mgf1_32_params_test.json':           "fb5c743dafffae4fa96564d50be5decb8712d8247e4066f0e2eee040bc0fd0d458a803e72327151dc7eae93223455f162c6ef46d7c5650a1abc9e483c5f262ac",
+	'rsa_pss_4096_sha512_mgf1_32_test.json':           "b1e6ee3d4a7be1562237e8362450319df027318042111eb11add1bb0cc5e35db274962dc6f61718fcb83165a8ed8fe0adaf3d446b2e2b75486ddb948574e0d08",
+	'rsa_pss_4096_sha512_mgf1_64_params_test.json':           "61109281f59667eaec913bd98ba9dd5b84418fe697331a6dc9b53720833f98da64c8b561b57c853c797f7d5de8ae212554eb6836087d62d016f9208835844b05",
+	'rsa_pss_4096_sha512_mgf1_64_test.json':           "fb3632478e0d261741443865f5cbe7954103186ecf8098d5c52f88b2f85c870961a3c90599e256fe46185f8b6ab8b1c36b326aa30fea4090f5e55eb6b9ff3544",
+	'rsa_pss_4096_shake256_test.json':           "5add00e096f35b72f062f169a4c6cb11ea8f93235d9ff7ea72b4ab4d226fd8a470368dfd5335b4f7abf3a5cb3f81759a8c99ca8209c4891e0d7bc08ffaa4ab5a",
+	'rsa_pss_misc_params_test.json':           "aa871f1dcd047e116f67edf398a839ee9e93f301ba746592a4f718d1f351e1dfaa731501ae18881217ce48086258a7c0a107a85c900bf3ecff4d64f639f98a17",
+	'rsa_pss_misc_test.json':           "2ad28380f1455adf0048369df811c7c6d6a3c7002945e3f30ef889243f94b62f8602ad7f461f616dfbe0b75c96269eac86f99ad6288d842ddc3c9cc4fd7b3dd6",
+	'rsa_signature_2048_sha224_test.json':           "6601b34eaf82d03c3c3b1b4041a7009de8aaf2c4e3bf527519ce237ba94b38b848e3bbf04eaacd3d084d3bef9126f2f4ff9b678126fc3fdfa5429503a028f546",
+	'rsa_signature_2048_sha256_test.json':           "d5150fe23f6215406edc768682ea71070f49c8f4a718b2f3da113e9a5213577f2c79e1eff1d4506c8ba89fc42ecbb5fd301a47c26030490f4ac06f2feabc936e",
+	'rsa_signature_2048_sha384_test.json':           "cb045c76ad23f9fdb3abb38bcfa7a78cea1e13a7f512e777cd44b21f644d96ebe780d042435b4ed32f16582745c895fff4ddf9071b7f7c4bbbd0a71631b4f57d",
+	'rsa_signature_2048_sha3_224_test.json':           "527f64300e61defd85cbe2d4c4f4eab2c2a6baa0ea16ba918ecf399c51ea530bf3b63f4322b3e7a0eee15aaf50d1cc851cc076b30219c2bb0b2d28348006e3fb",
+	'rsa_signature_2048_sha3_256_test.json':           "1038614b3760b2d57017c266985e17527002eac224945c4584da572611c46d0ca2b58293b663b7709bbb27646802634dab8d4fb123f36fad01f5a74b1324e23d",
+	'rsa_signature_2048_sha3_384_test.json':           "d386a2a69d558f9a4f5d09795486d628044c5b56fe34c4d5d66063533133541594b4f5f9330541cdeebd1c1ab7a11488d96a852e5fd69ba9fa08c9157d102fd6",
+	'rsa_signature_2048_sha3_512_test.json':           "f5ea0d29bb0887f9401bafff3cdc35a45c0196070616df75e5ac8a12caaf5e238080eceb4265962aae4e299f991be73eb0e4fddead0bc795e32b023547160761",
+	'rsa_signature_2048_sha512_224_test.json':           "96e0032b3af2ae3a8d5626a79488a112926b599f1f9fc4e47d5d7941898a5dbb0afe689de16bc79dcf13656e0b32e052b6704bdec673ae2b99383b68285cdbd5",
+	'rsa_signature_2048_sha512_256_test.json':           "fe54c5821e526f3374d03e7c1313e3783cd986b07a4c9858bcf3aa20d8c85b27d898394b4c37c1483fc16ca1ac5b59681ace58fba625f84feb9af7455d38ab20",
+	'rsa_signature_2048_sha512_test.json':           "2b9f6c3da08266a40b7529443aa42738bf7fd23842ad3792cdee9a587fd6056bf7eb1ec72867d3006f1a98728a3e528575ffdd7229325e13fafd6f363edda0a7",
+	'rsa_signature_3072_sha256_test.json':           "17999b3add8f853b07d6ca9e24fd58b275abb725bca8f7203787f57d8af0c03f7bdc15a6eacee1337d9621b2d53a8cac86de7b2e6a444abe81da8139838a8c7e",
+	'rsa_signature_3072_sha384_test.json':           "9f9a8ee0d78bb6481d94c1f9e41eb77438f33308c163c1634ec122dffe133fdef9c5cf1eb8c7ce4b0161df651f2d04a0250fa25d7fc82deb9eea105fe69121f2",
+	'rsa_signature_3072_sha3_256_test.json':           "6f4b2e8ba2436fe4c21e3d19e4a8572227bae64e9860a55462fc1b439900e9f443fbea4c5294cf262805d35ff8360ce48ea6c80ec5e4d82ad70c193680c8e28e",
+	'rsa_signature_3072_sha3_384_test.json':           "05b4a8736086dd21af73e84240ecf2ae217d45aab051f5c65744ac95777e82ca45bd0026881e08b1d817e7e015ccd8372e7d4c83356e896914307242eabab0b0",
+	'rsa_signature_3072_sha3_512_test.json':           "f188eb1849e68f30fb8d7e925ec6c575702ef0b1b06db618db558f35a01c4e541e8dedcb10e4eeec416cff82a4136a086cb2fc3b9e37434e4a5d8b5d11004d4e",
+	'rsa_signature_3072_sha512_256_test.json':           "d9e04c0bb74c874f1a51219b1dcba0b23780f64fb552d810683a48d1e47809acb84a4b2ce54e17f77be15b1798bbef64eb44c0722920dd96deff9472f5262093",
+	'rsa_signature_3072_sha512_test.json':           "23b528243e764425738dcafdd598845c59a3d8bbaeeefe432fb25f8ade7fd611f4f336d3fa91e079b149ea125c1d9d889317606a351827fb73b93a2dc8301e09",
+	'rsa_signature_4096_sha256_test.json':           "13c86fcb11277e72dbb54cd1e4c4cfadbc5605eeba3672130827a593b6bb703d927138bafee5daa03ae30bae15a352bf22abcdf518cebacd0f5b55c08bdaeccb",
+	'rsa_signature_4096_sha384_test.json':           "8881628f3b4015a729d88167fa98b3be5eb9cbda23e6766d5ba45a4a00dfa684d60cd269662e6df54771b7393cf01ce0fecdd572395606ad2e9d129e0b992a0f",
+	'rsa_signature_4096_sha512_256_test.json':           "6cd08b03cba8779ac57782d4030dff7fe277393aa1e308a647c5be1a64066eb0faf43a3e5f526bc76706e8e0d808c5b37ee4a4e0046e61aa68b41f1b80306a43",
+	'rsa_signature_4096_sha512_test.json':           "021cb140c1f7f7f87c22cf891c40ae5544f1c92926e9c8ea7af838ea496bb4dba646c120fe6fe75d81808cdbb515799bcfc8df1b1c3cbb4f9561821891a6d92b",
+	'rsa_signature_8192_sha256_test.json':           "8dbea635f9123af876287f583849b29186030cd270b709dd08b272f03acf4cec0c3cc3e77d45542ad606d101e59cb7feafe8af094f2bc2b38bc3cf08d8169266",
+	'rsa_signature_8192_sha384_test.json':           "c518417449709d88f3ad7aa1307b60a5d17fb575754674523a848b5030fa89a0501b396fb5fdc77902eec3f000272cb28458efe3473a80a407dcea0de6a06a8f",
+	'rsa_signature_8192_sha512_test.json':           "1cd1800f716214697507df8c099c3c01f512491ef8c008003da8f83326e3d08476365c96c03f91e0f22395f99fc01aa750aeee254fa22f81dc903418f41784bb",
+	'rsa_three_primes_oaep_2048_sha1_mgf1sha1_test.json':           "c629e7997fcec21d05891d944ab5fffcd673e5f2eb26b3931885f900081d9cfd63dfc09e009e95972118e1f1096803ca108c425b996ae0f83b90e9ecf3277247",
+	'rsa_three_primes_oaep_3072_sha224_mgf1sha224_test.json':           "d74d361bae2e5516ae5595afd929dbab2dcb03802c89899a6d097b86b1a815cb2237a55cf5e54df6179f08ebff573a03f59815fe2869308b752f52812ce7f6b0",
+	'rsa_three_primes_oaep_4096_sha256_mgf1sha256_test.json':           "214c700242fc7bad97b8086b13b4c607c7a51e4fa6eb0ba0263741c97ecd7969cbdb85bf0359254080da13e112af458b8fd0a100178b10ef5881162ec3658345",
+	'seed_ccm_test.json':           "b9d61c16f439b9547ce15344b806d98f36da7030f31d4eab1c558029d4e3410470b97e8d471a27dc75eb74ecec99cdcfb7911b605e5f700b665e50d6a7ad42be",
+	'seed_gcm_test.json':           "422745f91d72d71d3d1238269ba1dc6234f2a5445d637988acd86d9a383bdfde5391bf5c3c3d4fa0f9fc415d371a9724b2f76f0535229eadc29bda0c01d2c812",
+	'seed_wrap_test.json':           "a87be3d6c8127970b617d67f35b95be529808273a078bf82f2d8b2bbde2a6608e21559c2a2ee276552745da6cb1f0a253eca67991af2b05b57ed7487ff2fed4f",
+	'siphashx_2_4_test.json':           "72d16dcd5b56f08079146c79918f3b80a442a17cdc62b2097c8c2956f799e90ba9cca9d80cc8b0220b7f1fb83b4a1e27b6658cc5cd24e2f5c42a57fc47e4cd64",
+	'siphashx_4_8_test.json':           "d183ba80de092cd66ff8443286b9d22d838d79214827d02aa5323081d578d9dab21485cdeb6c0dda59d151bb6d0596d50d8254836fd25d9278f1a795f5d807d4",
+	'siphash_1_3_test.json':           "ac056415a0d4e45d802179b7efeebd034a7fc2110fee14b293e16af1edf95448a12160a6e6c2d95b36fe937102ba33264b29c2b1eb452df2ac766fe29b368436",
+	'siphash_2_4_test.json':           "d7cff2d63f881285567f9aeaca23fc2c94ea465fb442687b0ea94e9647eddcfc05d1b36c2435482b1d492c32b21fc50636a258e2e9c62d9ae6ddbabc93564ca9",
+	'siphash_4_8_test.json':           "6e49e401186510df582b68df50f8b331ad67609e18fbffe4adb359eb8d9e8f727a6abf3f4d5de1f33f4efb82b86a07f004f49c52d2c5e775e9319fd2c7d969e7",
+	'sm4_ccm_test.json':           "e963c49fab1e0d8ee050658e797d8c5b2d80cce39fa338833d46a2d7bc5e54036a41610063c0c74644e56589d1697396e1bfa4925e7a5592fa2247cb983441f0",
+	'sm4_gcm_test.json':           "9f64992c6c5469827d281a55c1612b0029fe344322c8cd7a7f2cefecc597dfb0f3f7b6cf85153f79e12c3539d553d591a8e9a1d0d714a58fb967e6fdfdfebc30",
+	'vmac_128_test.json':           "9fc97358a5ad56d4badc2b2ba35c07cd4872cf3687da667fddc3f628765330e6a9fc179e55c9a28b87cc02c92b80461d4db99073637fb17b1cf2a74bd5347a68",
+	'vmac_64_test.json':           "835e384b5d53bef8680520fc2ddb94ecc5d30e8aa65cdf0c6a48615e93273850d6333e19670d0ad40eeee645ebfd5c139f377518987e37ea6f6e6b28a22d0bde",
+	'x25519_asn_test.json':           "d43e2003c96c50c616cb093b8bcc4f70ca8931d2be83b1ca860900acaf65cd25ab347100c1a6fcb2561f1f29eedb52ff3e1bde70b29a757d4f814daf3cad35db",
+	'x25519_jwk_test.json':           "2f7f54dccb9c0882ec4a5e9da7c7779d18b7551729e805d2db51bd84a16abd07dcc3b0d7c922dc322b2da05708f0e00c612cea1b2d0c6f567aca09d846629b7e",
+	'x25519_pem_test.json':           "73530bc171e3a9ab5d82236a8c9c2fa4e565d8e1c83169036920ed22aa29f1122dbda9cae1c33dc5366b2b21aeec377930d6c305e6f00404bf25c4e679572841",
+	'x25519_test.json':           "857144ffa55ca421df7231594b23a5ed5b83f0f04ac1a707177c6d80d3cf1f69f42436abd3d7b2551788064cdbf01a2e2e25e0272d1ca8bc4a943b981dccefd5",
+	'x448_asn_test.json':           "b4fe61c5b1a57a887e539afe815ed970afba6eca055b674cb615945df39da911aeb41092570fcf480b5ad347520cc678aa0baf93ae574b272ce2457b802d4dcd",
+	'x448_jwk_test.json':           "402813856f68470b39df34e160211b53f90cfeba63c6b32c8b49d4d4bfa60b68c94cd1a04fdc09f07676a8f2942bc227ef75165456f6055cc0df3cc1e4381cd4",
+	'x448_pem_test.json':           "718ef327a5e8cc3a34467974193a051efe89323352f32f248c874457f28f6a2836cb6c2c15f40044df96428051591766fc0b44771236145a17835e714360ca51",
+	'x448_test.json':           "ca811349ede46fc253d656c26b058e2fe903aae8a225d7f6703bef3dec122df4c48af190a070df4c4066690f50ed4996d69089794b5484b57f2c4233216f98f5",
+	'xchacha20_poly1305_test.json':           "5debf381018af54fa2f9041044a257f8faff85b9a2eda314f21a05a55de2aacd2767a4962ecc58f69ed65404dc7d2b1eb8526038e7641610ce3a988456838fce",
 }
 
 def try_download_file(url, out_file):
@@ -324,11 +665,12 @@ def try_download_and_unpack_zip(suite):
 				digest = hashlib.sha3_512(file_data).hexdigest()
 
 				hmac_digest = hmac.new(HMAC_KEY.encode(), file_data, HMAC_HASH).hexdigest()
-				print("{} *{}".format(hmac_digest, file.filename))
 
 				if not hmac.compare_digest(hmac_digest, HMAC_DIGESTS[file.filename]):
-				 	print("FAIL! Expected: {}".format(HMAC_DIGESTS[file.filename]))
+				 	print("❌ Expected {}, got {} for {}".format(HMAC_DIGESTS[file.filename], hmac_digest, file.filename))
 				 	return 4
+				else:
+					print("✅ {} *{}".format(hmac_digest, file.filename))
 
 	#except:
 	#	print("Could not extract ZIP file")