#!/usr/bin/env python3 """ Run the Wycheproof tests This script is run against a git checkout of Wycheproof (C) 2026 Jack Lloyd (C) 2026 Rene Meusel, Rohde & Schwarz Cybersecurity Botan is released under the Simplified BSD License (see license.txt) """ import argparse import base64 import binascii import ctypes import io import json import multiprocessing import os import subprocess import sys import traceback from collections import Counter from collections.abc import Callable from dataclasses import dataclass, field from pathlib import Path import botan3 as botan # ---- Framework ---- class TestSkip(Exception): """Raised by a handler to skip a test vector.""" def __init__(self, reason: str): self.reason = reason super().__init__(reason) class TestFailure(Exception): """Raised by a handler when a test vector fails. Can be constructed with either: - A dict of field_name -> value for .vec-style output - A plain string message """ def __init__(self, fields_or_message): if isinstance(fields_or_message, dict): self.fields = fields_or_message msg = "; ".join(f"{k}={v}" for k, v in fields_or_message.items()) else: self.fields = None msg = str(fields_or_message) super().__init__(msg) class FixedOutputRNG(botan.RandomNumberGenerator): def __init__(self, entropy_pool: bytes = b""): super().__init__( "custom", get_callback=self._get, add_entropy_callback=self._add_entropy ) self._entropy_pool = entropy_pool def _get(self, length: int) -> bytes: if length > len(self._entropy_pool): raise ValueError("Not enough entropy in pool") entropy = self._entropy_pool[:length] self._entropy_pool = self._entropy_pool[length:] return entropy def _add_entropy(self, data: bytes) -> None: self._entropy_pool += data class NullRNG(botan.RandomNumberGenerator): """An RNG that raises an exception if it is used.""" def __init__(self): super().__init__( "custom", get_callback=self._get, add_entropy_callback=self._add_entropy ) def _get(self, length: int) -> bytes: raise botan.BotanException("Unexpected request to get entropy from RNG", rc=-23) def _add_entropy(self, data: bytes) -> None: raise botan.BotanException("Unexpected request to add entropy to RNG", rc=-23) class _Registry: def __init__(self): self._handlers: dict[str, Callable] = {} self._ignored: set[str] = set() def register(self, algorithm: str, handler: Callable) -> None: if algorithm in self._handlers: raise RuntimeError( f"Algorithm {algorithm!r} already registered by " f"{self._handlers[algorithm].__name__}, " f"cannot also register {handler.__name__}" ) self._handlers[algorithm] = handler def get(self, algorithm: str) -> Callable | None: return self._handlers.get(algorithm) def ignore(self, *algorithms: str) -> None: for algo in algorithms: if algo in self._handlers: raise RuntimeError(f"Algorithm {algo!r} is both registered and ignored") self._ignored.add(algo) def is_ignored(self, algorithm: str) -> bool: return algorithm in self._ignored _registry = _Registry() def register(*algorithms: str): """Decorator to register a handler for one or more Wycheproof algorithm values.""" def decorator(func): for algo in algorithms: _registry.register(algo, func) return func return decorator @dataclass class _FileResult: """Result of processing a single JSON file.""" filename: str category: str # "claimed", "unclaimed", "ignored", "no_algorithm" algorithm: str | None = None passed: int = 0 failed: int = 0 errors: int = 0 skipped: int = 0 skip_reasons: dict[str, int] = field(default_factory=dict) output: str = "" def _process_file(args: tuple[str, int]) -> _FileResult: json_path_str, verbosity = args json_path = Path(json_path_str) filename = json_path.name data = json.loads(json_path.read_bytes()) algorithm = data.get("algorithm") if algorithm is None: return _FileResult(filename, "no_algorithm") if _registry.is_ignored(algorithm): return _FileResult(filename, "ignored", algorithm=algorithm) handler = _registry.get(algorithm) if handler is None: return _FileResult(filename, "unclaimed", algorithm=algorithm) result = _FileResult(filename, "claimed", algorithm=algorithm) out = io.StringIO() if verbosity >= 2: print(f"{filename} ({algorithm}):", file=out) for group in data["testGroups"]: for test in group["tests"]: tc_id = test.get("tcId", "?") try: handler(data, group, test) result.passed += 1 if verbosity >= 2: print(f" PASS: test {tc_id}", file=out) except TestSkip as e: result.skipped += 1 reason = str(e) result.skip_reasons[reason] = result.skip_reasons.get(reason, 0) + 1 if verbosity >= 2: print(f" SKIP: test {tc_id}: {reason}", file=out) except TestFailure as e: result.failed += 1 print(f"\nFAIL: # Wycheproof test {tc_id} from {filename}", file=out) if e.fields: for key, value in e.fields.items(): print(f"{key} = {value}", file=out) else: print(f" {e}", file=out) except Exception as e: result.errors += 1 print(f"\nERROR: # Wycheproof test {tc_id} from {filename}", file=out) print(f" {type(e).__name__}: {e}", file=out) print(traceback.format_exc(), file=out) result.output = out.getvalue() return result def _git_rev(directory: str) -> str | None: """Return the git revision of a directory, or None if not a git repo.""" try: result = subprocess.run( ["git", "rev-parse", "HEAD"], cwd=directory, capture_output=True, text=True, timeout=5, check=True, ) if result.returncode == 0: return result.stdout.strip() except (FileNotFoundError, subprocess.TimeoutExpired, subprocess.CalledProcessError): pass return None def run( wycheproof_dir: str, verbosity: int = 1, jobs: int | None = None, filters: list[str] | None = None, ) -> int: """Main entry point. Returns 0 on success, 1 on failure.""" tv_dir = Path(wycheproof_dir) / "testvectors_v1" if not tv_dir.is_dir(): print(f"ERROR: {tv_dir} is not a directory") return 1 wycheproof_rev = _git_rev(wycheproof_dir) json_paths = sorted(tv_dir.glob("*.json")) if filters: filters_lower = [f.lower() for f in filters] filtered = [] for p in json_paths: if any(f in p.name.lower() for f in filters_lower): filtered.append(p) continue algo = json.loads(p.read_bytes()).get("algorithm", "") if any(f in algo.lower() for f in filters_lower): filtered.append(p) json_paths = filtered work = [(str(p), verbosity) for p in json_paths] if jobs == 1: file_results = [_process_file(item) for item in work] else: with multiprocessing.Pool(jobs) as pool: file_results = pool.map(_process_file, work) # Aggregate results and print buffered output passed = 0 failed = 0 errors = 0 skipped = 0 files_claimed = 0 files_ignored = 0 unclaimed: list[tuple[str, str]] = [] no_algorithm: list[str] = [] skip_reasons: Counter[str] = Counter() for fr in file_results: if fr.output: sys.stderr.write(fr.output) if fr.category == "no_algorithm": no_algorithm.append(fr.filename) elif fr.category == "ignored": files_ignored += 1 elif fr.category == "unclaimed": unclaimed.append((fr.filename, fr.algorithm)) else: files_claimed += 1 passed += fr.passed failed += fr.failed errors += fr.errors skipped += fr.skipped for reason, count in fr.skip_reasons.items(): skip_reasons[reason] += count # Print summary total_files = files_claimed + files_ignored + len(unclaimed) + len(no_algorithm) total_tests = passed + failed + errors + skipped print("Wycheproof Results") print("Botan version: %s" % (botan.version_string())) print("Wycheproof revision: %s" % (wycheproof_rev)) print("Total %d Passed %d Failed %d Errors %d Skipped %d" % (total_tests, passed, failed, errors, skipped)) print( f"Files: {total_files} total, {files_claimed} claimed, " f"{files_ignored} ignored, {len(unclaimed)} unclaimed", ) if verbosity >= 1: if skip_reasons: print("\nSkipped tests (by reason):") for reason, count in skip_reasons.most_common(): print(f" {count}x: {reason}") if unclaimed: print(f"\nUnclaimed files ({len(unclaimed)}):") for filename, algorithm in unclaimed: print(f" {filename} ({algorithm})") if no_algorithm: print(f"\nFiles without algorithm field ({len(no_algorithm)}):") for filename in no_algorithm: print(f" {filename}") return 0 if (failed == 0 and errors == 0) else 1 # ---- Common utilities ---- def _from_hex(value: str) -> bytes: return binascii.unhexlify(value) def _b64url_decode(s: str) -> bytes: return base64.urlsafe_b64decode(s + "=" * (4 - len(s) % 4)) _CURVE_NAME_MAP = { "brainpoolP224r1": "brainpool224r1", "brainpoolP256r1": "brainpool256r1", "brainpoolP320r1": "brainpool320r1", "brainpoolP384r1": "brainpool384r1", "brainpoolP512r1": "brainpool512r1", "P-256": "secp256r1", "P-384": "secp384r1", "P-521": "secp521r1", } _HASH_NAME_MAP = { "SHA-1": "SHA-1", "SHA-224": "SHA-224", "SHA-256": "SHA-256", "SHA-384": "SHA-384", "SHA-512": "SHA-512", "SHA-512/256": "SHA-512-256", "SHA3-224": "SHA-3(224)", "SHA3-256": "SHA-3(256)", "SHA3-384": "SHA-3(384)", "SHA3-512": "SHA-3(512)", "SHAKE128": "SHAKE-128(256)", "SHAKE256": "SHAKE-256(512)", } # ---- AEAD handler ---- _AEAD_CIPHER_ALIASES = { "AES-GCM": "AES", "AES-CCM": "AES", "AEAD-AES-SIV-CMAC": "AES-SIV-CMAC", "ARIA-GCM": "ARIA", "ARIA-CCM": "ARIA", "CAMELLIA-CCM": "Camellia", "SEED-GCM": "SEED", "SEED-CCM": "SEED", "SM4-GCM": "SM4", "SM4-CCM": "SM4", } def _aead_algorithm( algorithm: str, key_size_bits: int, tag_size_bits: int | None, nonce_len: int ) -> str: tag_len_bytes = tag_size_bits // 8 if tag_size_bits is not None else None if algorithm in ("AEAD-AES-SIV-CMAC", "AES-SIV-CMAC"): return f"AES-{key_size_bits // 2}/SIV" if algorithm == "AES-EAX": return f"AES-{key_size_bits}/EAX" if algorithm == "AES-GCM-SIV": if tag_size_bits is not None and tag_size_bits != 128: raise ValueError(f"AES-GCM-SIV requires a 128-bit tag not {tag_size_bits}") return f"AES-{key_size_bits}/GCM-SIV" if algorithm in ("CHACHA20-POLY1305", "XCHACHA20-POLY1305"): return "ChaCha20Poly1305" cipher = _AEAD_CIPHER_ALIASES.get(algorithm) if cipher is None: raise ValueError(f"Unsupported AEAD algorithm: {algorithm}") if cipher in ("AES", "ARIA", "Camellia"): cipher = f"{cipher}-{key_size_bits}" if algorithm.endswith("GCM"): suffix = f"/GCM({tag_len_bytes})" if tag_len_bytes is not None else "/GCM" return f"{cipher}{suffix}" if algorithm.endswith("CCM"): l_val = 15 - nonce_len if tag_len_bytes is None: return f"{cipher}/CCM({l_val})" return f"{cipher}/CCM({tag_len_bytes},{l_val})" raise ValueError(f"Unhandled AEAD algorithm: {algorithm}") def _aead_process( aead: botan.SymmetricCipher, iv: bytes, aad: bytes, data: bytes ) -> bytes: aead.set_assoc_data(aad) aead.start(iv) return aead.finish(data) @register( "AES-GCM", "AES-GCM-SIV", "AES-CCM", "AES-EAX", "AEAD-AES-SIV-CMAC", "AES-SIV-CMAC", "ARIA-GCM", "ARIA-CCM", "CAMELLIA-CCM", "SEED-GCM", "SEED-CCM", "SM4-GCM", "SM4-CCM", "CHACHA20-POLY1305", "XCHACHA20-POLY1305", ) def handle_aead(data: dict, group: dict, test: dict) -> None: algorithm = data["algorithm"] is_siv = algorithm in ("AEAD-AES-SIV-CMAC", "AES-SIV-CMAC") tag_size_bits = group.get("tagSize") key_size_bits = group.get("keySize") key = _from_hex(test["key"]) iv = _from_hex(test.get("iv", "")) aad = _from_hex(test.get("aad", "")) msg = _from_hex(test["msg"]) ct = _from_hex(test["ct"]) tag = _from_hex(test["tag"]) if "tag" in test else b"" expected_ct_tag = (tag + ct) if is_siv else (ct + tag) algo = _aead_algorithm(algorithm, key_size_bits, tag_size_bits, len(iv)) def _fields(**extra): fields = {"Key": test["key"], "Msg": test["msg"]} if "iv" in test: fields["Nonce"] = test["iv"] if "aad" in test: fields["AD"] = test["aad"] fields["CT"] = test["ct"] if "tag" in test: fields["Tag"] = test["tag"] fields.update(extra) return fields if test["result"] == "valid": enc = botan.SymmetricCipher(algo, True) enc.set_key(key) enc_out = _aead_process(enc, iv, aad, msg) if enc_out != expected_ct_tag: raise TestFailure(_fields(ComputedCT=enc_out.hex())) dec = botan.SymmetricCipher(algo, False) dec.set_key(key) dec_out = _aead_process(dec, iv, aad, expected_ct_tag) if dec_out != msg: raise TestFailure(_fields(DecryptedMsg=dec_out.hex())) elif test["result"] in ("invalid", "acceptable"): try: dec = botan.SymmetricCipher(algo, False) dec.set_key(key) dec_out = _aead_process(dec, iv, aad, expected_ct_tag) if test["result"] == "invalid": raise TestFailure( _fields( DecryptedMsg=dec_out.hex(), Note="Invalid AEAD test decrypted without authentication failure", ) ) if test["result"] == "acceptable" and dec_out != msg: raise TestFailure( _fields( DecryptedMsg=dec_out.hex(), Note="Acceptable test decrypted to wrong plaintext", ) ) except botan.BotanException: pass else: raise TestFailure(f"Unknown test result: {test['result']}") # ---- ECDH handler ---- @register("ECDH") def handle_ecdh(_data: dict, group: dict, test: dict) -> None: group_type = group.get("type", "") if group_type not in ( "EcdhTest", "EcdhEcpointTest", "EcdhPemTest", "EcdhWebcryptoTest", ): raise TestSkip(f"ECDH group type {group_type!r} not supported") curve = _CURVE_NAME_MAP.get(group["curve"], group["curve"]) if not botan.ECGroup.supports_named_group(curve): raise TestSkip(f"Curve {curve} not supported in this build") try: if group_type == "EcdhPemTest": # PEM EC keys load as ECDSA by default; re-create as ECDH pem_key = botan.PrivateKey.load(test["private"].encode()) priv_key = botan.PrivateKey.load_ecdh(curve, pem_key.get_field("x")) elif group_type == "EcdhWebcryptoTest": priv_d = int.from_bytes(_b64url_decode(test["private"]["d"]), "big") priv_key = botan.PrivateKey.load_ecdh(curve, botan.MPI(priv_d)) else: priv_key = botan.PrivateKey.load_ecdh( curve, botan.MPI(test["private"], radix=16) ) except botan.BotanException: if test["result"] != "valid": return raise if group_type == "EcdhEcpointTest": pub_raw = _from_hex(test["public"]) elif group_type == "EcdhWebcryptoTest": if "InvalidPublic" in test.get("flags", []): raise TestSkip("JWK structural validation test") pub_x = _b64url_decode(test["public"]["x"]) pub_y = _b64url_decode(test["public"]["y"]) pub_raw = b"\x04" + pub_x + pub_y elif group_type == "EcdhPemTest": try: pub_key = botan.PublicKey.load(test["public"].encode()) except botan.BotanException: if test["result"] != "valid": return raise if pub_key.used_explicit_encoding(): if test["result"] not in ("invalid", "acceptable"): raise TestFailure( { "Curve": curve, "Note": "Explicit curve encoding on valid test", } ) return pub_raw = pub_key.to_raw() else: try: pub_key = botan.PublicKey.load(_from_hex(test["public"])) except botan.BotanException: if test["result"] != "valid": return raise if pub_key.used_explicit_encoding(): if test["result"] not in ("invalid", "acceptable"): raise TestFailure( { "Curve": curve, "Private": test["private"], "Public": test["public"], "Note": "Explicit curve encoding on valid test", } ) return pub_raw = pub_key.to_raw() try: ka = botan.PKKeyAgreement(priv_key, "Raw") shared_secret = ka.agree(pub_raw, 0, b"") except botan.BotanException: if test["result"] != "valid": return raise if test["result"] not in ("valid", "acceptable"): raise TestFailure( { "Curve": curve, "Private": test["private"], "Public": test["public"], "Shared": shared_secret.hex(), "Note": "Invalid test case produced a shared secret", } ) expected = _from_hex(test["shared"]) if shared_secret != expected: raise TestFailure( { "Curve": curve, "Private": test["private"], "Public": test["public"], "Shared": test["shared"], "ComputedShared": shared_secret.hex(), } ) # ---- ECDSA handler ---- @register("ECDSA") def handle_ecdsa(_data: dict, group: dict, test: dict) -> None: botan_hash = _map_hash(group["sha"]) curve = _CURVE_NAME_MAP.get( group["publicKey"]["curve"], group["publicKey"]["curve"] ) if not botan.ECGroup.supports_named_group(curve): raise TestSkip(f"Curve {curve} not supported in this build") try: pub_key = botan.PublicKey.load(_from_hex(group["publicKeyDer"])) except botan.BotanException: if test["result"] != "valid": return raise group_type = group["type"] if group_type == "EcdsaBitcoinVerify": raise TestSkip("Bitcoin variant of ECDSA is not supported") if group_type in ("EcdsaVerify", "EcdsaBitcoinVerify"): use_der = True elif group_type == "EcdsaP1363Verify": use_der = False else: raise TestFailure(f"Unknown test group type: {group_type}") try: verifier = botan.PKVerify(pub_key, botan_hash, der=use_der) verifier.update(_from_hex(test["msg"])) valid = verifier.check_signature(_from_hex(test["sig"])) except botan.BotanException: if test["result"] != "valid": return raise expected_valid = test["result"] == "valid" if valid != expected_valid: raise TestFailure( { "Curve": curve, "Hash": group["sha"], "Msg": test["msg"], "Sig": test["sig"], "Expected": "valid" if expected_valid else "invalid", "Got": "valid" if valid else "invalid", } ) # ---- HKDF handler ---- _HKDF_ALIASES = { "HKDF-SHA-1": "HKDF(SHA-1)", "HKDF-SHA-256": "HKDF(SHA-256)", "HKDF-SHA-384": "HKDF(SHA-384)", "HKDF-SHA-512": "HKDF(SHA-512)", } @register("HKDF-SHA-1", "HKDF-SHA-256", "HKDF-SHA-384", "HKDF-SHA-512") def handle_hkdf(data: dict, _group: dict, test: dict) -> None: algo = _HKDF_ALIASES.get(data["algorithm"]) if algo is None: raise ValueError(f"Unsupported HKDF algorithm: {data['algorithm']}") ikm = _from_hex(test["ikm"]) salt = _from_hex(test["salt"]) info = _from_hex(test["info"]) size = test["size"] expected = _from_hex(test["okm"]) try: actual = botan.kdf(algo, ikm, size, salt, info) except botan.BotanException: if test["result"] in ("invalid", "acceptable"): return raise if test["result"] == "valid": if actual != expected: raise TestFailure( { "IKM": test["ikm"], "Salt": test["salt"], "Info": test["info"], "Size": str(size), "OKM": test["okm"], "ComputedOKM": actual.hex(), } ) elif test["result"] == "invalid": if actual == expected: raise TestFailure( { "IKM": test["ikm"], "Salt": test["salt"], "Info": test["info"], "Size": str(size), "OKM": test["okm"], "Note": "Invalid test produced matching output", } ) elif test["result"] == "acceptable": pass else: raise TestFailure(f"Unknown test result: {test['result']}") # ---- PBKDF2 handler ---- _PBKDF2_ALIASES = { "PBKDF2-HMACSHA1": "PBKDF2(SHA-1)", "PBKDF2-HMACSHA224": "PBKDF2(SHA-224)", "PBKDF2-HMACSHA256": "PBKDF2(SHA-256)", "PBKDF2-HMACSHA384": "PBKDF2(SHA-384)", "PBKDF2-HMACSHA512": "PBKDF2(SHA-512)", } @register( "PBKDF2-HMACSHA1", "PBKDF2-HMACSHA224", "PBKDF2-HMACSHA256", "PBKDF2-HMACSHA384", "PBKDF2-HMACSHA512", ) def handle_pbkdf2(data: dict, _group: dict, test: dict) -> None: algo = _PBKDF2_ALIASES[data["algorithm"]] password = _from_hex(test["password"]) salt = _from_hex(test["salt"]) iterations = test["iterationCount"] dk_len = test["dkLen"] expected = _from_hex(test["dk"]) try: out_buf = ctypes.create_string_buffer(dk_len) # pylint: disable=protected-access raw_algo = botan._ctype_str(algo) # pylint: disable=protected-access botan._DLL.botan_pwdhash( raw_algo, iterations, 0, 0, out_buf, dk_len, password, len(password), salt, len(salt), ) actual = out_buf.raw except botan.BotanException: if test["result"] in ("invalid", "acceptable"): return raise if test["result"] == "valid": if actual != expected: raise TestFailure( { "Password": test["password"], "Salt": test["salt"], "Iterations": str(iterations), "DkLen": str(dk_len), "DK": test["dk"], "ComputedDK": actual.hex(), } ) elif test["result"] == "invalid": if actual == expected: raise TestFailure( { "Password": test["password"], "Salt": test["salt"], "Iterations": str(iterations), "DkLen": str(dk_len), "DK": test["dk"], "Note": "Invalid test produced matching output", } ) elif test["result"] == "acceptable": pass else: raise TestFailure(f"Unknown test result: {test['result']}") # ---- MAC handler ---- _MAC_ALGORITHMS = { "HMACSHA1": "HMAC(SHA-1)", "HMACSHA224": "HMAC(SHA-224)", "HMACSHA256": "HMAC(SHA-256)", "HMACSHA384": "HMAC(SHA-384)", "HMACSHA512": "HMAC(SHA-512)", "HMACSHA3-224": "HMAC(SHA-3(224))", "HMACSHA3-256": "HMAC(SHA-3(256))", "HMACSHA3-384": "HMAC(SHA-3(384))", "HMACSHA3-512": "HMAC(SHA-3(512))", "HMACSM3": "HMAC(SM3)", "HMACSHA512/256": "HMAC(SHA-512-256)", "SipHash-1-3": "SipHash(1,3)", "SipHash-2-4": "SipHash(2,4)", "SipHash-4-8": "SipHash(4,8)", "KMAC128": "KMAC-128", "KMAC256": "KMAC-256", } _CMAC_CIPHERS = { "AES-CMAC": "AES", "ARIA-CMAC": "ARIA", "CAMELLIA-CMAC": "Camellia", } def _mac_algorithm( algorithm: str, key_size_bits: int | None, tag_size_bits: int | None ) -> str: if algorithm == "AES-GMAC": if key_size_bits is None: raise ValueError("AES-GMAC requires a key size") return f"GMAC(AES-{key_size_bits})" if algorithm.startswith("KMAC"): if tag_size_bits is None: raise ValueError("KMAC requires a tag size") return f"{_MAC_ALGORITHMS[algorithm]}({tag_size_bits})" if algorithm in _CMAC_CIPHERS: if key_size_bits is None: raise ValueError(f"{algorithm} requires a key size") return f"CMAC({_CMAC_CIPHERS[algorithm]}-{key_size_bits})" return _MAC_ALGORITHMS[algorithm] @register( "HMACSHA1", "HMACSHA224", "HMACSHA256", "HMACSHA384", "HMACSHA512", "HMACSHA3-224", "HMACSHA3-256", "HMACSHA3-384", "HMACSHA3-512", "HMACSM3", "HMACSHA512/256", "SipHash-1-3", "SipHash-2-4", "SipHash-4-8", "AES-GMAC", "KMAC128", "KMAC256", "AES-CMAC", "ARIA-CMAC", "CAMELLIA-CMAC", ) def handle_mac(data: dict, group: dict, test: dict) -> None: key_size_bits = group.get("keySize") iv_size_bits = group.get("ivSize") tag_size_bits = group.get("tagSize") algo = _mac_algorithm(data["algorithm"], key_size_bits, tag_size_bits) try: mac = botan.MsgAuthCode(algo) mac.set_key(_from_hex(test["key"])) except botan.BotanException: if test["result"] != "valid": return raise if iv_size_bits is not None: mac.set_nonce(_from_hex(test["iv"])) mac.update(_from_hex(test["msg"])) final_mac = mac.final() actual_mac = ( final_mac[: tag_size_bits // 8] if tag_size_bits is not None else final_mac ) expected = _from_hex(test["tag"]) if test["result"] == "valid": if actual_mac != expected: raise TestFailure( { "Key": test["key"], "Msg": test["msg"], "Tag": test["tag"], "ComputedTag": actual_mac.hex(), } ) elif test["result"] == "invalid": if actual_mac == expected: raise TestFailure( { "Key": test["key"], "Msg": test["msg"], "Tag": test["tag"], "Note": "Invalid test produced matching MAC", } ) elif test["result"] == "acceptable": pass else: raise TestFailure(f"Unknown test result: {test['result']}") # ---- ML-DSA handler ---- _MLDSA_MODE_MAP = { "ML-DSA-44": "ML-DSA-4x4", "ML-DSA-65": "ML-DSA-6x5", "ML-DSA-87": "ML-DSA-8x7", } def _mldsa_sign_test(mldsa_mode: str, group: dict, test: dict) -> None: priv = None try: if "privateSeed" in group: priv = botan.PrivateKey.load_ml_dsa( mldsa_mode, _from_hex(group["privateSeed"]) ) # TODO: implement loading from expanded private key except botan.BotanException: if test["result"] == "invalid": return raise if priv is None: raise TestSkip("ML-DSA noseed (expanded private key) not yet supported") pub = priv.get_public_key() if "publicKey" in group and group["publicKey"] is not None: expected_pk = _from_hex(group["publicKey"]) if pub.to_raw() != expected_pk: raise TestFailure( { "Mode": mldsa_mode, "PrivateSeed": group.get("privateSeed", ""), "PublicKey": group["publicKey"], "ComputedPublicKey": pub.to_raw().hex(), "Note": "Deserialized public key does not match expected", } ) try: if "rnd" in test: signer = botan.PKSign(priv, "Randomized") signer.update(_from_hex(test["msg"])) actual_sig = signer.finish(FixedOutputRNG(_from_hex(test["rnd"]))) else: signer = botan.PKSign(priv, "Deterministic") signer.update(_from_hex(test["msg"])) actual_sig = signer.finish(NullRNG()) except botan.BotanException: if test["result"] == "invalid": return raise expected_sig = _from_hex(test["sig"]) if actual_sig != expected_sig: raise TestFailure( { "Mode": mldsa_mode, "Msg": test["msg"], "Sig": test["sig"], "ComputedSig": actual_sig.hex(), } ) def _mldsa_verify_test(mldsa_mode: str, group: dict, test: dict) -> None: try: pub = botan.PublicKey.load_ml_dsa(mldsa_mode, _from_hex(group["publicKey"])) except botan.BotanException: if test["result"] == "invalid": return raise verifier = botan.PKVerify(pub, "") verifier.update(_from_hex(test["msg"])) valid = verifier.check_signature(_from_hex(test["sig"])) expected_valid = test["result"] == "valid" if valid != expected_valid: raise TestFailure( { "Mode": mldsa_mode, "Msg": test["msg"], "Sig": test["sig"], "Expected": "valid" if expected_valid else "invalid", "Got": "valid" if valid else "invalid", } ) @register("ML-DSA-44", "ML-DSA-65", "ML-DSA-87") def handle_mldsa(data: dict, group: dict, test: dict) -> None: ctx = test.get("ctx") if ctx is not None and ctx != "": raise TestSkip("ML-DSA ctx not supported") if "msg" not in test or ("flags" in test and "Internal" in test["flags"]): raise TestSkip("ML-DSA's Sign_internal interface is not exposed") mldsa_mode = _MLDSA_MODE_MAP.get( data.get("algorithm", ""), data.get("algorithm", "") ) group_type = group.get("type") if group_type == "MlDsaSign": _mldsa_sign_test(mldsa_mode, group, test) elif group_type == "MlDsaVerify": _mldsa_verify_test(mldsa_mode, group, test) else: raise TestFailure(f"Unknown test group type: {group_type}") # ---- ML-KEM handler ---- @register("ML-KEM") def handle_mlkem(_data: dict, group: dict, test: dict) -> None: mlkem_mode = group["parameterSet"] group_type = group.get("type", "") if group_type == "MLKEMDecapsValidationTest": raise TestSkip("ML-KEM semi-expanded decapsulation not yet supported") priv = None pub = None if "seed" in test: try: priv = botan.PrivateKey.load_ml_kem(mlkem_mode, _from_hex(test["seed"])) except botan.BotanException: if test["result"] == "invalid": return raise pub = priv.get_public_key() if "ek" in test: expected_ek = _from_hex(test["ek"]) if pub is None: try: pub = botan.PublicKey.load_ml_kem(mlkem_mode, expected_ek) except botan.BotanException: if test["result"] == "invalid": return raise if pub.to_raw() != expected_ek: raise TestFailure( { "Mode": mlkem_mode, "Seed": test.get("seed", ""), "EK": test["ek"], "ComputedEK": pub.to_raw().hex(), } ) if not pub: raise ValueError("No public key available in this test vector") if "dk" in test: try: expected_dk = _from_hex(test["dk"]) priv2 = botan.PrivateKey.load_ml_kem(mlkem_mode, expected_dk) # TODO: currently we cannot export the expanded private key via the python API if priv2.to_raw() != expected_dk: raise TestFailure( { "Mode": mlkem_mode, "DK": test["dk"], "ComputedDK": priv2.to_raw().hex(), } ) if priv2.get_public_key().to_raw() != pub.to_raw(): raise TestFailure( { "Mode": mlkem_mode, "DK": test["dk"], "Note": "Private key's public key does not match expected", } ) except botan.BotanException: if test["result"] in ("invalid", "acceptable"): return raise if "c" in test and "K" in test: expected_k = _from_hex(test["K"]) expected_c = _from_hex(test["c"]) if "m" in test: rng = FixedOutputRNG(_from_hex(test["m"])) kem_e = botan.KemEncrypt(pub, "Raw") actual_k, actual_c = kem_e.create_shared_key(rng, b"", len(expected_k)) if actual_k != expected_k: raise TestFailure( { "Mode": mlkem_mode, "K": test["K"], "ComputedK": actual_k.hex(), } ) if actual_c != expected_c: raise TestFailure( { "Mode": mlkem_mode, "C": test["c"], "ComputedC": actual_c.hex(), } ) if priv is not None: kem_d = botan.KemDecrypt(priv, "Raw") try: actual_k = kem_d.decrypt_shared_key(b"", len(expected_k), expected_c) except botan.BotanException: if test["result"] in ("invalid", "acceptable"): return raise if test["result"] == "valid": if actual_k != expected_k: raise TestFailure( { "Mode": mlkem_mode, "K": test["K"], "C": test["c"], "ComputedK": actual_k.hex(), } ) elif test["result"] == "invalid": if actual_k == expected_k: raise TestFailure( { "Mode": mlkem_mode, "K": test["K"], "C": test["c"], "Note": "Invalid test produced matching shared key", } ) elif test["result"] == "acceptable": pass else: raise TestFailure(f"Unknown test result: {test['result']}") # ---- Symmetric cipher handlers (non-AEAD) ---- _BLOCK_CIPHER_MAP = { "AES-CBC-PKCS5": ("AES", "/CBC/PKCS7", 1), "ARIA-CBC-PKCS5": ("ARIA", "/CBC/PKCS7", 1), "CAMELLIA-CBC-PKCS5": ("Camellia", "/CBC/PKCS7", 1), "AES-XTS": ("AES", "/XTS", 2), } @register("AES-CBC-PKCS5", "ARIA-CBC-PKCS5", "CAMELLIA-CBC-PKCS5", "AES-XTS") def handle_block_cipher(data: dict, group: dict, test: dict) -> None: cipher_base, mode, key_divisor = _BLOCK_CIPHER_MAP[data["algorithm"]] key_size = group["keySize"] // key_divisor algo = f"{cipher_base}-{key_size}{mode}" key = _from_hex(test["key"]) iv = _from_hex(test["iv"]) msg = _from_hex(test["msg"]) ct = _from_hex(test["ct"]) def _fields(**extra): fields = { "Key": test["key"], "IV": test["iv"], "Msg": test["msg"], "CT": test["ct"], } fields.update(extra) return fields if test["result"] == "valid": try: enc = botan.SymmetricCipher(algo, True) enc.set_key(key) enc.start(iv) enc_out = enc.finish(msg) except botan.BotanException: # pylint: disable=raise-missing-from raise TestFailure(_fields(Note="Encryption failed")) if enc_out != ct: raise TestFailure(_fields(ComputedCT=enc_out.hex())) try: dec = botan.SymmetricCipher(algo, False) dec.set_key(key) dec.start(iv) dec_out = dec.finish(ct) except botan.BotanException: # pylint: disable=raise-missing-from raise TestFailure(_fields(Note="Decryption failed")) if dec_out != msg: raise TestFailure(_fields(DecryptedMsg=dec_out.hex())) elif test["result"] in ("invalid", "acceptable"): try: dec = botan.SymmetricCipher(algo, False) dec.set_key(key) dec.start(iv) dec_out = dec.finish(ct) if test["result"] == "invalid" and dec_out == msg: raise TestFailure(_fields(Note="Invalid test decrypted successfully")) except botan.BotanException: pass else: raise TestFailure(f"Unknown test result: {test['result']}") # ---- Key wrap handlers ---- _KEYWRAP_CIPHERS = { "AES-WRAP": "AES-{keySize}", "AES-KWP": "AES-{keySize}", "ARIA-WRAP": "ARIA-{keySize}", "ARIA-KWP": "ARIA-{keySize}", "CAMELLIA-WRAP": "Camellia-{keySize}", "SEED-WRAP": "SEED", } def _keywrap_cipher(algorithm: str, key_size: int) -> str: template = _KEYWRAP_CIPHERS[algorithm] return template.format(keySize=key_size) @register("AES-WRAP", "ARIA-WRAP", "CAMELLIA-WRAP", "SEED-WRAP") def handle_keywrap(data: dict, group: dict, test: dict) -> None: cipher = _keywrap_cipher(data["algorithm"], group["keySize"]) key = _from_hex(test["key"]) msg = _from_hex(test["msg"]) ct = _from_hex(test["ct"]) if test["result"] == "valid": wrapped = botan.nist_key_wrap(key, msg, cipher) if wrapped != ct: raise TestFailure( { "Key": test["key"], "Msg": test["msg"], "CT": test["ct"], "ComputedCT": wrapped.hex(), } ) try: unwrapped = botan.nist_key_unwrap(key, ct, cipher) except botan.BotanException: # pylint: disable=raise-missing-from raise TestFailure( { "Key": test["key"], "CT": test["ct"], "Note": "Valid wrap unwrap failed", } ) if unwrapped != msg: raise TestFailure( { "Key": test["key"], "CT": test["ct"], "Msg": test["msg"], "ComputedMsg": unwrapped.hex(), } ) elif test["result"] == "invalid": try: unwrapped = botan.nist_key_unwrap(key, ct, cipher) if unwrapped == msg: raise TestFailure( { "Key": test["key"], "CT": test["ct"], "Note": "Invalid wrap unwrapped successfully", } ) except botan.BotanException: pass elif test["result"] == "acceptable": pass else: raise TestFailure(f"Unknown test result: {test['result']}") @register("AES-KWP", "ARIA-KWP") def handle_keywrap_padded(data: dict, group: dict, test: dict) -> None: cipher = _keywrap_cipher(data["algorithm"], group["keySize"]) key = _from_hex(test["key"]) msg = _from_hex(test["msg"]) ct = _from_hex(test["ct"]) if test["result"] == "valid": wrapped = botan.nist_key_wrap_padded(key, msg, cipher) if wrapped != ct: raise TestFailure( { "Key": test["key"], "Msg": test["msg"], "CT": test["ct"], "ComputedCT": wrapped.hex(), } ) try: unwrapped = botan.nist_key_unwrap_padded(key, ct, cipher) except botan.BotanException: # pylint: disable=raise-missing-from raise TestFailure( { "Key": test["key"], "CT": test["ct"], "Note": "Valid padded wrap unwrap failed", } ) if unwrapped != msg: raise TestFailure( { "Key": test["key"], "CT": test["ct"], "Msg": test["msg"], "ComputedMsg": unwrapped.hex(), } ) elif test["result"] == "invalid": try: unwrapped = botan.nist_key_unwrap_padded(key, ct, cipher) if unwrapped == msg: raise TestFailure( { "Key": test["key"], "CT": test["ct"], "Note": "Invalid padded wrap unwrapped successfully", } ) except botan.BotanException: pass elif test["result"] == "acceptable": pass else: raise TestFailure(f"Unknown test result: {test['result']}") # ---- DSA handler ---- @register("DSA") def handle_dsa(_data: dict, group: dict, test: dict) -> None: group_type = group["type"] if group_type == "DsaVerify": use_der = True elif group_type == "DsaP1363Verify": use_der = False else: raise TestFailure(f"Unknown DSA group type: {group_type}") try: pub_key = botan.PublicKey.load(_from_hex(group["publicKeyDer"])) except botan.BotanException: if test["result"] != "valid": return raise botan_hash = _map_hash(group["sha"]) try: verifier = botan.PKVerify(pub_key, botan_hash, der=use_der) verifier.update(_from_hex(test["msg"])) valid = verifier.check_signature(_from_hex(test["sig"])) except botan.BotanException: if test["result"] != "valid": return raise expected_valid = test["result"] == "valid" if valid != expected_valid: raise TestFailure( { "Hash": group["sha"], "Msg": test["msg"], "Sig": test["sig"], "Expected": "valid" if expected_valid else "invalid", "Got": "valid" if valid else "invalid", } ) # ---- EdDSA handler ---- @register("EDDSA") def handle_eddsa(_data: dict, group: dict, test: dict) -> None: try: pub_key = botan.PublicKey.load(_from_hex(group["publicKeyDer"])) except botan.BotanException: if test["result"] != "valid": return raise try: verifier = botan.PKVerify(pub_key, "Pure") verifier.update(_from_hex(test["msg"])) valid = verifier.check_signature(_from_hex(test["sig"])) except botan.BotanException: if test["result"] != "valid": return raise expected_valid = test["result"] == "valid" if valid != expected_valid: raise TestFailure( { "Curve": group["publicKey"]["curve"], "Msg": test["msg"], "Sig": test["sig"], "Expected": "valid" if expected_valid else "invalid", "Got": "valid" if valid else "invalid", } ) # ---- RSA signature handlers ---- def _map_hash(name: str) -> str: h = _HASH_NAME_MAP.get(name) if h is None: raise TestSkip(f"Hash {name} not supported") return h def _rsa_pss_padding(group: dict) -> str: if group.get("mgf") != "MGF1": raise TestSkip(f"PSS with {group.get('mgf')} MGF not supported") sha = _map_hash(group["sha"]) mgf_sha = _map_hash(group["mgfSha"]) if sha != mgf_sha: raise TestSkip("PSS with different MGF hash not supported") s_len = group["sLen"] return f"PSSR({sha},MGF1,{s_len})" def _rsa_pkcs1_padding(group: dict) -> str: return f"EMSA3({_map_hash(group['sha'])})" def _rsa_verify(pub_key, padding: str, test: dict) -> None: try: verifier = botan.PKVerify(pub_key, padding) verifier.update(_from_hex(test["msg"])) valid = verifier.check_signature(_from_hex(test["sig"])) except botan.BotanException: if test["result"] != "valid": return raise expected_valid = test["result"] == "valid" if valid != expected_valid: raise TestFailure( { "Msg": test["msg"], "Sig": test["sig"], "Padding": padding, "Expected": "valid" if expected_valid else "invalid", "Got": "valid" if valid else "invalid", } ) @register("RSASSA-PKCS1-v1_5") def handle_rsa_pkcs1_sig(_data: dict, group: dict, test: dict) -> None: group_type = group["type"] if group_type == "RsassaPkcs1Verify": try: pub_key = botan.PublicKey.load(_from_hex(group["publicKeyDer"])) except botan.BotanException: if test["result"] != "valid": return raise _rsa_verify(pub_key, _rsa_pkcs1_padding(group), test) elif group_type == "RsassaPkcs1Generate": try: priv_key = botan.PrivateKey.load(_from_hex(group["privateKeyPkcs8"])) except botan.BotanException: if test["result"] != "valid": return raise padding = _rsa_pkcs1_padding(group) try: signer = botan.PKSign(priv_key, padding) signer.update(_from_hex(test["msg"])) actual_sig = signer.finish(botan.RandomNumberGenerator("system")) except botan.BotanException: if test["result"] != "valid": return raise expected_sig = _from_hex(test["sig"]) if actual_sig != expected_sig: raise TestFailure( { "Msg": test["msg"], "Padding": padding, "Sig": test["sig"], "ComputedSig": actual_sig.hex(), } ) else: raise TestFailure(f"Unknown RSA PKCS1 sig group type: {group_type}") @register("RSASSA-PSS") def handle_rsa_pss_sig(_data: dict, group: dict, test: dict) -> None: group_type = group["type"] if group_type not in ("RsassaPssVerify", "RsassaPssWithParametersVerify"): raise TestFailure(f"Unknown RSA PSS group type: {group_type}") try: pub_key = botan.PublicKey.load(_from_hex(group["publicKeyDer"])) except botan.BotanException: if test["result"] != "valid": return raise _rsa_verify(pub_key, _rsa_pss_padding(group), test) # ---- RSA encryption handlers ---- def _rsa_oaep_padding(group: dict) -> str: sha = _map_hash(group["sha"]) mgf_sha = _map_hash(group["mgfSha"]) return f"OAEP({sha},MGF1({mgf_sha}))" @register("RSAES-OAEP") def handle_rsa_oaep(_data: dict, group: dict, test: dict) -> None: if "otherPrimeInfos" in group.get("privateKey", {}): raise TestSkip("Multi-prime RSA not supported") # Botan's OAEP label parameter only accepts string labels, not arbitrary binary if test.get("label", "") != "": raise TestSkip("OAEP with binary label not supported in padding string parser") try: priv_key = botan.PrivateKey.load(_from_hex(group["privateKeyPkcs8"])) except botan.BotanException: if test["result"] != "valid": return raise padding = _rsa_oaep_padding(group) try: decryptor = botan.PKDecrypt(priv_key, padding) plaintext = decryptor.decrypt(_from_hex(test["ct"])) except botan.BotanException: if test["result"] != "valid": return raise expected = _from_hex(test["msg"]) if test["result"] == "valid": if plaintext != expected: raise TestFailure( { "Ctext": test["ct"], "Ptext": test["msg"], "Padding": padding, "ComputedMsg": plaintext.hex(), } ) elif test["result"] == "invalid": if plaintext == expected: raise TestFailure( { "Ctext": test["ct"], "Ptext": test["msg"], "Padding": padding, "Note": "Invalid test decrypted successfully", } ) @register("RSAES-PKCS1-v1_5") def handle_rsa_pkcs1_enc(_data: dict, group: dict, test: dict) -> None: try: priv_key = botan.PrivateKey.load(_from_hex(group["privateKeyPkcs8"])) except botan.BotanException: if test["result"] != "valid": return raise try: decryptor = botan.PKDecrypt(priv_key, "PKCS1v15") plaintext = decryptor.decrypt(_from_hex(test["ct"])) except botan.BotanException: if test["result"] != "valid": return raise expected = _from_hex(test["msg"]) if test["result"] == "valid": if plaintext != expected: raise TestFailure( { "Ctext": test["ct"], "Ptext": test["msg"], "ComputedMsg": plaintext.hex(), } ) elif test["result"] == "invalid": if plaintext == expected: raise TestFailure( { "Ctext": test["ct"], "Ptext": test["msg"], "Note": "Invalid test decrypted successfully", } ) # ---- XDH handler (X25519, X448) ---- _XDH_LOAD_RAW = { "curve25519": botan.PrivateKey.load_x25519, "curve448": botan.PrivateKey.load_x448, } @register("XDH") def handle_xdh(_data: dict, group: dict, test: dict) -> None: group_type = group.get("type", "") curve = group.get("curve", "") expected = _from_hex(test["shared"]) # Load private key and public key bytes based on encoding format try: if group_type == "XdhComp": load_fn = _XDH_LOAD_RAW.get(curve) if load_fn is None: raise TestSkip(f"XDH curve {curve} not supported") priv_key = load_fn(_from_hex(test["private"])) pub_bytes = _from_hex(test["public"]) elif group_type in ("XdhAsnComp", "XdhPemComp"): if group_type == "XdhAsnComp": priv_key = botan.PrivateKey.load(_from_hex(test["private"])) pub_key = botan.PublicKey.load(_from_hex(test["public"])) else: priv_key = botan.PrivateKey.load(test["private"].encode()) pub_key = botan.PublicKey.load(test["public"].encode()) pub_bytes = pub_key.to_raw() elif group_type == "XdhJwkComp": load_fn = _XDH_LOAD_RAW.get(curve) if load_fn is None: raise TestSkip(f"XDH curve {curve} not supported") # We extract raw bytes from the JWK, bypassing JWK structural # validation (kty, crv, missing fields). Skip InvalidPublic # tests since those test JWK parsing, not the crypto. if "InvalidPublic" in test.get("flags", []): raise TestSkip("JWK structural validation test") priv_key = load_fn(_b64url_decode(test["private"]["d"])) pub_bytes = _b64url_decode(test["public"]["x"]) else: raise TestSkip(f"XDH group type {group_type!r} not supported") except (botan.BotanException, KeyError, ValueError): if test["result"] != "valid": return raise try: ka = botan.PKKeyAgreement(priv_key, "Raw") shared = ka.agree(pub_bytes, 0, b"") except botan.BotanException: if test["result"] != "valid": return raise if test["result"] not in ("valid", "acceptable"): raise TestFailure( { "Curve": curve, "Shared": shared.hex(), "Note": "Invalid test case produced a shared secret", } ) if shared != expected: raise TestFailure( { "Curve": curve, "Shared": test["shared"], "ComputedShared": shared.hex(), } ) # ---- Primality test handler ---- @register("PrimalityTest") def handle_primality(_data: dict, _group: dict, test: dict) -> None: value = test["value"] if value in ["", "00"]: return # This test encodes integers as signed twos complement for unclear reasons value_bytes = _from_hex(value) if value_bytes[0] & 0x80: is_prime = False else: n = botan.MPI(value, radix=16) rng = botan.RandomNumberGenerator("system") is_prime = n.is_prime(rng) expected_prime = test["result"] == "valid" if is_prime != expected_prime: raise TestFailure( { "Value": value, "Expected": "prime" if expected_prime else "composite", "Got": "prime" if is_prime else "composite", } ) # ---- Ignored algorithms ---- _registry.ignore( "AES-FF1", # Not implemented "A128CBC-HS256", # Not implemented "A192CBC-HS384", # Not implemented "A256CBC-HS512", # Not implemented "AEGIS128", # Not implemented "AEGIS128L", # Not implemented "AEGIS256", # Not implemented "ASCON128", # Pre-NIST Ascon not implemented "ASCON128A", # Pre-NIST Ascon not implemented "ASCON80PQ", # Pre-NIST Ascon not implemented "BLS", # Not implemented "PbeWithHmacSha1AndAes_128", # PBES2 not directly exposed in API "PbeWithHmacSha1AndAes_192", "PbeWithHmacSha1AndAes_256", "PbeWithHmacSha224AndAes_128", "PbeWithHmacSha224AndAes_192", "PbeWithHmacSha224AndAes_256", "PbeWithHmacSha256AndAes_128", "PbeWithHmacSha256AndAes_192", "PbeWithHmacSha256AndAes_256", "PbeWithHmacSha384AndAes_128", "PbeWithHmacSha384AndAes_192", "PbeWithHmacSha384AndAes_256", "PbeWithHmacSha512AndAes_128", "PbeWithHmacSha512AndAes_192", "PbeWithHmacSha512AndAes_256", "EcCurveTest", # Not even clear what this is for "MORUS640", # Not implemented "MORUS1280", # Not implemented "HMACSHA512/224", # Not implemented "SipHashX-2-4", # 128-bit SipHash variant, not implemented "SipHashX-4-8", # 128-bit SipHash variant, not implemented "VMAC-AES", # Not implemented ) # ---- Entry point ---- def main() -> int: parser = argparse.ArgumentParser( description="Run Wycheproof test vectors against Botan's Python bindings" ) parser.add_argument( "wycheproof_dir", nargs="?", default=os.environ.get("WYCHEPROOF_DIR"), help="path to Wycheproof git checkout (default: $WYCHEPROOF_DIR)", ) parser.add_argument("--verbose", "-v", action="store_true", help="be noisy") parser.add_argument("--quiet", "-q", action="store_true", help="be quiet") parser.add_argument( "--jobs", "-j", type=int, default=None, help="number of workers" ) parser.add_argument( "--filter", "-f", action="append", default=[], help="only run files matching FILTER (case-insensitive substring of filename or algorithm, may be repeated)", ) args = parser.parse_args() if args.wycheproof_dir is None: parser.error( "wycheproof_dir argument or WYCHEPROOF_DIR environment variable required" ) jobs = args.jobs if jobs is not None and jobs <= 0: parser.error("Invalid --jobs parameter") verbosity = 0 if args.quiet else (2 if args.verbose else 1) return run(args.wycheproof_dir, verbosity, jobs, args.filter or None) if __name__ == "__main__": sys.exit(main())