From 394e306633a7e8898b8d6d1bee5bd247de6ae705 Mon Sep 17 00:00:00 2001 From: Egor Tensin Date: Sat, 13 Jun 2026 17:58:56 +0200 Subject: workflows/ci: add linting for Python test scripts --- .github/workflows/ci.yml | 10 +++++ test/cavp.py | 94 +++++++++++++++++++++++++++++------------- test/file.py | 66 +++++++++++++++++++----------- test/nist.py | 104 +++++++++++++++++++++++++++-------------------- test/toolkit.py | 39 ++++++++++-------- 5 files changed, 200 insertions(+), 113 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 3c1cac2..3d429f0 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -21,6 +21,16 @@ jobs: uses: egor-tensin/clang-format@v1 with: version: 22 + - name: Set up Python + uses: actions/setup-python@v6 + with: + python-version: '3.x' + - name: Run black + uses: psf/black@stable + with: + # > Please note that the --check flag is required so that the + # > workflow fails if Black finds files that need to be formatted. + options: --check --verbose --skip-string-normalization build: strategy: diff --git a/test/cavp.py b/test/cavp.py index 95aa4a6..b96969d 100755 --- a/test/cavp.py +++ b/test/cavp.py @@ -78,7 +78,8 @@ class TestFile: dict_type=_MultiOrderedDict, strict=False, interpolation=None, - empty_lines_in_values=False) + empty_lines_in_values=False, + ) with open(self._path) as fd: parser.read_string(fd.read()) self._encryption_data = self._parse_data_section(parser, 'ENCRYPT') @@ -94,11 +95,15 @@ class TestFile: @staticmethod def _split_into_chunks(expected_output, inputs, max_len=100): for i in range(0, len(inputs), max_len): - yield expected_output[i:i+max_len], inputs[i:i+max_len] + yield expected_output[i : i + max_len], inputs[i : i + max_len] def _run_tests(self, tool, inputs, expected_output, use_boxes=False): - for expected_output_chunk, input_chunk in self._split_into_chunks(expected_output, list(inputs)): - actual_output = tool(self.algorithm(), self.mode(), input_chunk, use_boxes=use_boxes) + for expected_output_chunk, input_chunk in self._split_into_chunks( + expected_output, list(inputs) + ): + actual_output = tool( + self.algorithm(), self.mode(), input_chunk, use_boxes=use_boxes + ) if not verify_test_output(actual_output, expected_output_chunk): return TestExitCode.FAILURE return TestExitCode.SUCCESS @@ -110,7 +115,9 @@ class TestFile: try: keys, plaintexts, ciphertexts, init_vectors = self._encryption_data inputs = self._gen_inputs(keys, plaintexts, init_vectors) - return self._run_tests(tools.run_encrypt_block, inputs, ciphertexts, use_boxes) + return self._run_tests( + tools.run_encrypt_block, inputs, ciphertexts, use_boxes + ) except CalledProcessError as e: logging.error('Encountered an exception!') logging.exception(e) @@ -123,7 +130,9 @@ class TestFile: try: keys, plaintexts, ciphertexts, init_vectors = self._decryption_data inputs = self._gen_inputs(keys, ciphertexts, init_vectors) - return self._run_tests(tools.run_decrypt_block, inputs, plaintexts, use_boxes) + return self._run_tests( + tools.run_decrypt_block, inputs, plaintexts, use_boxes + ) except CalledProcessError as e: logging.error('Encountered an exception!') logging.exception(e) @@ -132,13 +141,17 @@ class TestFile: def _parse_path(self): logging.debug('Trying to parse test file path \'%s\'...', self._path) stub = self._strip_extension(os.path.basename(self._path)) - if not stub: return + if not stub: + return stub = self._strip_algorithm(stub) - if not stub: return + if not stub: + return stub = self._strip_method(stub) - if not stub: return + if not stub: + return stub = self._strip_mode(stub) - if not stub: return + if not stub: + return self._recognized = True _RECOGNIZED_EXT = '.rsp' @@ -166,7 +179,7 @@ class TestFile: for method in self._RECOGNIZED_METHODS: if stub.endswith(method): logging.debug('\tMethod: %s', method) - return stub[0:len(stub) - len(method)] + return stub[0 : len(stub) - len(method)] logging.warning('Unknown or unsupported method: %s', self._path) return None @@ -195,11 +208,13 @@ _script_dir = os.path.dirname(__file__) def _setup_logging(verbose=False): level = logging.DEBUG if verbose else logging.INFO logging.basicConfig( - format='%(asctime)s | %(module)s | %(levelname)s | %(message)s', - level=level) + format='%(asctime)s | %(module)s | %(levelname)s | %(message)s', level=level + ) -def run_tests(archive_path, tools_path=(), use_sde=False, use_boxes=False, verbose=False): +def run_tests( + archive_path, tools_path=(), use_sde=False, use_boxes=False, verbose=False +): _setup_logging(verbose) tools = Tools(tools_path, use_sde=use_sde) archive = TestArchive(archive_path) @@ -215,8 +230,10 @@ def run_tests(archive_path, tools_path=(), use_sde=False, use_boxes=False, verbo logging.info('\tSucceeded: %d', exit_codes.count(TestExitCode.SUCCESS)) logging.info('\tFailed: %d', exit_codes.count(TestExitCode.FAILURE)) - if (exit_codes.count(TestExitCode.ERROR) == 0 and - exit_codes.count(TestExitCode.FAILURE) == 0): + if ( + exit_codes.count(TestExitCode.ERROR) == 0 + and exit_codes.count(TestExitCode.FAILURE) == 0 + ): return 0 else: return 1 @@ -226,18 +243,39 @@ def _parse_args(args=None): if args is None: args = sys.argv[1:] parser = argparse.ArgumentParser() - parser.add_argument('--path', '-p', dest='tools_path', metavar='PATH', - nargs='*', - help='set block encryption utilities directory path') - parser.add_argument('--sde', '-e', action='store_true', dest='use_sde', - help='use Intel SDE to run the utilities') - parser.add_argument('--boxes', '-b', action='store_true', dest='use_boxes', - help='use the "boxes" interface') - parser.add_argument('--archive', '-a', dest='archive_path', metavar='PATH', - default=os.path.join(_script_dir, 'data/KAT_AES.zip'), - help='set test vectors archive file path') - parser.add_argument('--verbose', '-v', action='store_true', - help='verbose log output') + parser.add_argument( + '--path', + '-p', + dest='tools_path', + metavar='PATH', + nargs='*', + help='set block encryption utilities directory path', + ) + parser.add_argument( + '--sde', + '-e', + action='store_true', + dest='use_sde', + help='use Intel SDE to run the utilities', + ) + parser.add_argument( + '--boxes', + '-b', + action='store_true', + dest='use_boxes', + help='use the "boxes" interface', + ) + parser.add_argument( + '--archive', + '-a', + dest='archive_path', + metavar='PATH', + default=os.path.join(_script_dir, 'data/KAT_AES.zip'), + help='set test vectors archive file path', + ) + parser.add_argument( + '--verbose', '-v', action='store_true', help='verbose log output' + ) return parser.parse_args(args) diff --git a/test/file.py b/test/file.py index a2f54d3..6930c8d 100755 --- a/test/file.py +++ b/test/file.py @@ -88,8 +88,9 @@ def _make_output_file(): os.remove(tmp_path) -def run_encryption_test(tools, algorithm, mode, key, plaintext_path, - ciphertext_path, iv=None, force=False): +def run_encryption_test( + tools, algorithm, mode, key, plaintext_path, ciphertext_path, iv=None, force=False +): logging.debug('Running encryption test...') logging.debug('\tPlaintext file path: %s', plaintext_path) logging.debug('\tExpected ciphertext file path: %s', ciphertext_path) @@ -100,8 +101,7 @@ def run_encryption_test(tools, algorithm, mode, key, plaintext_path, logging.debug('\tEncrypted file path: %s', tmp_path) try: - tools.run_encrypt_file(algorithm, mode, key, plaintext_path, - tmp_path, iv) + tools.run_encrypt_file(algorithm, mode, key, plaintext_path, tmp_path, iv) if force: logging.warning('Overwriting expected ciphertext file') shutil.copy(tmp_path, ciphertext_path) @@ -116,8 +116,9 @@ def run_encryption_test(tools, algorithm, mode, key, plaintext_path, return TestExitCode.ERROR -def run_decryption_test(tools, algorithm, mode, key, plaintext_path, - ciphertext_path, iv=None): +def run_decryption_test( + tools, algorithm, mode, key, plaintext_path, ciphertext_path, iv=None +): logging.debug('Running decryption test...') logging.debug('\tCiphertext file path: %s', ciphertext_path) logging.debug('\tExpected plaintext file path: %s', plaintext_path) @@ -128,8 +129,7 @@ def run_decryption_test(tools, algorithm, mode, key, plaintext_path, logging.debug('\tDecrypted file path: %s', tmp_path) try: - tools.run_decrypt_file(algorithm, mode, key, ciphertext_path, - tmp_path, iv) + tools.run_decrypt_file(algorithm, mode, key, ciphertext_path, tmp_path, iv) if filecmp.cmp(tmp_path, plaintext_path): return TestExitCode.SUCCESS logging.error('The decrypted file doesn\'t match the plaintext file') @@ -178,8 +178,8 @@ _script_name = os.path.splitext(os.path.basename(__file__))[0] def _setup_logging(verbose=False): level = logging.DEBUG if verbose else logging.INFO logging.basicConfig( - format='%(asctime)s | %(module)s | %(levelname)s | %(message)s', - level=level) + format='%(asctime)s | %(module)s | %(levelname)s | %(message)s', level=level + ) def run_tests(suite_path, tools_path=(), verbose=False, use_sde=False, force=False): @@ -197,8 +197,10 @@ def run_tests(suite_path, tools_path=(), verbose=False, use_sde=False, force=Fal logging.info('\tSucceeded: %d', exit_codes.count(TestExitCode.SUCCESS)) logging.info('\tFailed: %d', exit_codes.count(TestExitCode.FAILURE)) - if (exit_codes.count(TestExitCode.ERROR) == 0 and - exit_codes.count(TestExitCode.FAILURE) == 0): + if ( + exit_codes.count(TestExitCode.ERROR) == 0 + and exit_codes.count(TestExitCode.FAILURE) == 0 + ): return 0 else: return 1 @@ -208,18 +210,34 @@ def _parse_args(args=None): if args is None: args = sys.argv[1:] parser = argparse.ArgumentParser() - parser.add_argument('--path', '-p', dest='tools_path', metavar='PATH', - nargs='*', - help='set file encryption utilities directory path') - parser.add_argument('--sde', '-e', dest='use_sde', action='store_true', - help='use Intel SDE to run the utilities') - parser.add_argument('--verbose', '-v', action='store_true', - help='verbose log output') - parser.add_argument('--force', '-f', action='store_true', - help='overwrite ciphertext files') - parser.add_argument('--suite', '-s', dest='suite_path', - default=os.path.join(_script_dir, 'data', 'file'), - help='set test suite directory path') + parser.add_argument( + '--path', + '-p', + dest='tools_path', + metavar='PATH', + nargs='*', + help='set file encryption utilities directory path', + ) + parser.add_argument( + '--sde', + '-e', + dest='use_sde', + action='store_true', + help='use Intel SDE to run the utilities', + ) + parser.add_argument( + '--verbose', '-v', action='store_true', help='verbose log output' + ) + parser.add_argument( + '--force', '-f', action='store_true', help='overwrite ciphertext files' + ) + parser.add_argument( + '--suite', + '-s', + dest='suite_path', + default=os.path.join(_script_dir, 'data', 'file'), + help='set test suite directory path', + ) return parser.parse_args(args) diff --git a/test/nist.py b/test/nist.py index 6195d78..9cc0ce9 100755 --- a/test/nist.py +++ b/test/nist.py @@ -17,13 +17,13 @@ _TEST_PLAINTEXTS = [ '6bc1bee22e409f96e93d7e117393172a', 'ae2d8a571e03ac9c9eb76fac45af8e51', '30c81c46a35ce411e5fbc1191a0a52ef', - 'f69f2445df4f9b17ad2b417be66c3710' + 'f69f2445df4f9b17ad2b417be66c3710', ] _TEST_KEYS = { Algorithm.AES128: '2b7e151628aed2a6abf7158809cf4f3c', Algorithm.AES192: '8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b', - Algorithm.AES256: '603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4' + Algorithm.AES256: '603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4', } _TEST_INIT_VECTOR = '000102030405060708090a0b0c0d0e0f' @@ -34,7 +34,7 @@ _TEST_INIT_VECTORS = { Mode.CBC: _TEST_INIT_VECTOR, Mode.CFB: _TEST_INIT_VECTOR, Mode.OFB: _TEST_INIT_VECTOR, - Mode.CTR: _TEST_INIT_VECTOR_CTR + Mode.CTR: _TEST_INIT_VECTOR_CTR, } } @@ -47,97 +47,97 @@ _TEST_CIPHERTEXTS = { '3ad77bb40d7a3660a89ecaf32466ef97', 'f5d3d58503b9699de785895a96fdbaaf', '43b1cd7f598ece23881b00e3ed030688', - '7b0c785e27e8ad3f8223207104725dd4' + '7b0c785e27e8ad3f8223207104725dd4', ], Mode.CBC: [ '7649abac8119b246cee98e9b12e9197d', '5086cb9b507219ee95db113a917678b2', '73bed6b8e3c1743b7116e69e22229516', - '3ff1caa1681fac09120eca307586e1a7' + '3ff1caa1681fac09120eca307586e1a7', ], Mode.CFB: [ '3b3fd92eb72dad20333449f8e83cfb4a', 'c8a64537a0b3a93fcde3cdad9f1ce58b', '26751f67a3cbb140b1808cf187a4f4df', - 'c04b05357c5d1c0eeac4c66f9ff7f2e6' + 'c04b05357c5d1c0eeac4c66f9ff7f2e6', ], Mode.OFB: [ '3b3fd92eb72dad20333449f8e83cfb4a', '7789508d16918f03f53c52dac54ed825', '9740051e9c5fecf64344f7a82260edcc', - '304c6528f659c77866a510d9c1d6ae5e' + '304c6528f659c77866a510d9c1d6ae5e', ], Mode.CTR: [ '874d6191b620e3261bef6864990db6ce', '9806f66b7970fdff8617187bb9fffdff', '5ae4df3edbd5d35e5b4f09020db03eab', - '1e031dda2fbe03d1792170a0f3009cee' - ] + '1e031dda2fbe03d1792170a0f3009cee', + ], }, Algorithm.AES192: { Mode.ECB: [ 'bd334f1d6e45f25ff712a214571fa5cc', '974104846d0ad3ad7734ecb3ecee4eef', 'ef7afd2270e2e60adce0ba2face6444e', - '9a4b41ba738d6c72fb16691603c18e0e' + '9a4b41ba738d6c72fb16691603c18e0e', ], Mode.CBC: [ '4f021db243bc633d7178183a9fa071e8', 'b4d9ada9ad7dedf4e5e738763f69145a', '571b242012fb7ae07fa9baac3df102e0', - '08b0e27988598881d920a9e64f5615cd' + '08b0e27988598881d920a9e64f5615cd', ], Mode.CFB: [ 'cdc80d6fddf18cab34c25909c99a4174', '67ce7f7f81173621961a2b70171d3d7a', '2e1e8a1dd59b88b1c8e60fed1efac4c9', - 'c05f9f9ca9834fa042ae8fba584b09ff' + 'c05f9f9ca9834fa042ae8fba584b09ff', ], Mode.OFB: [ 'cdc80d6fddf18cab34c25909c99a4174', 'fcc28b8d4c63837c09e81700c1100401', '8d9a9aeac0f6596f559c6d4daf59a5f2', - '6d9f200857ca6c3e9cac524bd9acc92a' + '6d9f200857ca6c3e9cac524bd9acc92a', ], Mode.CTR: [ '1abc932417521ca24f2b0459fe7e6e0b', '090339ec0aa6faefd5ccc2c6f4ce8e94', '1e36b26bd1ebc670d1bd1d665620abf7', - '4f78a7f6d29809585a97daec58c6b050' - ] + '4f78a7f6d29809585a97daec58c6b050', + ], }, Algorithm.AES256: { Mode.ECB: [ 'f3eed1bdb5d2a03c064b5a7e3db181f8', '591ccb10d410ed26dc5ba74a31362870', 'b6ed21b99ca6f4f9f153e7b1beafed1d', - '23304b7a39f9f3ff067d8d8f9e24ecc7' + '23304b7a39f9f3ff067d8d8f9e24ecc7', ], Mode.CBC: [ 'f58c4c04d6e5f1ba779eabfb5f7bfbd6', '9cfc4e967edb808d679f777bc6702c7d', '39f23369a9d9bacfa530e26304231461', - 'b2eb05e2c39be9fcda6c19078c6a9d1b' + 'b2eb05e2c39be9fcda6c19078c6a9d1b', ], Mode.CFB: [ 'dc7e84bfda79164b7ecd8486985d3860', '39ffed143b28b1c832113c6331e5407b', 'df10132415e54b92a13ed0a8267ae2f9', - '75a385741ab9cef82031623d55b1e471' + '75a385741ab9cef82031623d55b1e471', ], Mode.OFB: [ 'dc7e84bfda79164b7ecd8486985d3860', '4febdc6740d20b3ac88f6ad82a4fb08d', '71ab47a086e86eedf39d1c5bba97c408', - '0126141d67f37be8538f5a8be740e484' + '0126141d67f37be8538f5a8be740e484', ], Mode.CTR: [ '601ec313775789a5b7a7f504bbf3d228', 'f443e3ca4d62b59aca84e990cacaf5c5', '2b0930daa23de94ce87017ba2d84988d', - 'dfc9c58db67aada613c2dd08457941a6' - ] - } + 'dfc9c58db67aada613c2dd08457941a6', + ], + }, } @@ -192,8 +192,7 @@ def run_encryption_test(tools, algorithm, mode, use_boxes=False): iv = get_test_iv(algorithm, mode) expected_ciphertexts = get_test_ciphertexts(algorithm, mode) input_ = BlockInput(key, plaintexts, iv=iv) - actual_ciphertexts = tools.run_encrypt_block( - algorithm, mode, input_, use_boxes) + actual_ciphertexts = tools.run_encrypt_block(algorithm, mode, input_, use_boxes) if verify_test_output(actual_ciphertexts, expected_ciphertexts): return TestExitCode.SUCCESS return TestExitCode.FAILURE @@ -214,8 +213,7 @@ def run_decryption_test(tools, algorithm, mode, use_boxes=False): iv = get_test_iv(algorithm, mode) expected_plaintexts = get_test_plaintexts(algorithm, mode) input_ = BlockInput(key, ciphertexts, iv=iv) - actual_plaintexts = tools.run_decrypt_block( - algorithm, mode, input_, use_boxes) + actual_plaintexts = tools.run_decrypt_block(algorithm, mode, input_, use_boxes) if verify_test_output(actual_plaintexts, expected_plaintexts): return TestExitCode.SUCCESS return TestExitCode.FAILURE @@ -228,8 +226,8 @@ def run_decryption_test(tools, algorithm, mode, use_boxes=False): def _setup_logging(verbose=False): level = logging.DEBUG if verbose else logging.INFO logging.basicConfig( - format='%(asctime)s | %(module)s | %(levelname)s | %(message)s', - level=level) + format='%(asctime)s | %(module)s | %(levelname)s | %(message)s', level=level + ) def run_tests(tools_path=(), use_sde=False, use_boxes=False, verbose=False): @@ -238,10 +236,12 @@ def run_tests(tools_path=(), use_sde=False, use_boxes=False, verbose=False): exit_codes = [] for algorithm, mode in get_tested_algorithms_and_modes(): - exit_codes.append(run_encryption_test( - tools, algorithm, mode, use_boxes=use_boxes)) - exit_codes.append(run_decryption_test( - tools, algorithm, mode, use_boxes=use_boxes)) + exit_codes.append( + run_encryption_test(tools, algorithm, mode, use_boxes=use_boxes) + ) + exit_codes.append( + run_decryption_test(tools, algorithm, mode, use_boxes=use_boxes) + ) logging.info('Test exit codes:') logging.info('\tSkipped: %d', exit_codes.count(TestExitCode.SKIPPED)) @@ -249,8 +249,10 @@ def run_tests(tools_path=(), use_sde=False, use_boxes=False, verbose=False): logging.info('\tSucceeded: %d', exit_codes.count(TestExitCode.SUCCESS)) logging.info('\tFailed: %d', exit_codes.count(TestExitCode.FAILURE)) - if (exit_codes.count(TestExitCode.ERROR) == 0 and - exit_codes.count(TestExitCode.FAILURE) == 0): + if ( + exit_codes.count(TestExitCode.ERROR) == 0 + and exit_codes.count(TestExitCode.FAILURE) == 0 + ): return 0 else: return 1 @@ -260,15 +262,31 @@ def _parse_args(args=None): if args is None: args = sys.argv[1:] parser = argparse.ArgumentParser() - parser.add_argument('--path', '-p', dest='tools_path', metavar='PATH', - nargs='*', - help='set block encryption utilities directory path') - parser.add_argument('--sde', '-e', action='store_true', dest='use_sde', - help='use Intel SDE to run the utilities') - parser.add_argument('--boxes', '-b', action='store_true', dest='use_boxes', - help='use the "boxes" interface') - parser.add_argument('--verbose', '-v', action='store_true', - help='verbose log output') + parser.add_argument( + '--path', + '-p', + dest='tools_path', + metavar='PATH', + nargs='*', + help='set block encryption utilities directory path', + ) + parser.add_argument( + '--sde', + '-e', + action='store_true', + dest='use_sde', + help='use Intel SDE to run the utilities', + ) + parser.add_argument( + '--boxes', + '-b', + action='store_true', + dest='use_boxes', + help='use the "boxes" interface', + ) + parser.add_argument( + '--verbose', '-v', action='store_true', help='verbose log output' + ) return parser.parse_args(args) diff --git a/test/toolkit.py b/test/toolkit.py index 650e81e..deafd8f 100644 --- a/test/toolkit.py +++ b/test/toolkit.py @@ -88,7 +88,8 @@ class Tools: logging.debug('Trying to execute: %s', subprocess.list2cmdline(cmd_list)) try: output = subprocess.check_output( - cmd_list, universal_newlines=True, stderr=subprocess.STDOUT) + cmd_list, universal_newlines=True, stderr=subprocess.STDOUT + ) except subprocess.CalledProcessError as e: logging.error('Output:\n%s', e.output) raise @@ -109,8 +110,10 @@ class Tools: @staticmethod def _block_settings_to_args(algorithm, mode, use_boxes=False): args = [ - '--algorithm', str(algorithm), - '--mode', str(mode), + '--algorithm', + str(algorithm), + '--mode', + str(mode), ] if use_boxes: args.append('--use-boxes') @@ -134,30 +137,30 @@ class Tools: return self.run(self._DECRYPT_BLOCK, args) @staticmethod - def _build_file_args( - algorithm, mode, key, input_path, output_path, iv=None): + def _build_file_args(algorithm, mode, key, input_path, output_path, iv=None): args = [ - '--algorithm', str(algorithm), - '--mode', str(mode), - '--key', key, - '--input', input_path, - '--output', output_path + '--algorithm', + str(algorithm), + '--mode', + str(mode), + '--key', + key, + '--input', + input_path, + '--output', + output_path, ] if iv is not None: args.extend(('--iv', iv)) return args - def run_encrypt_file( - self, algorithm, mode, key, input_path, output_path, iv=None): + def run_encrypt_file(self, algorithm, mode, key, input_path, output_path, iv=None): - args = self._build_file_args( - algorithm, mode, key, input_path, output_path, iv) + args = self._build_file_args(algorithm, mode, key, input_path, output_path, iv) return self.run(self._ENCRYPT_FILE, args) - def run_decrypt_file( - self, algorithm, mode, key, input_path, output_path, iv=None): + def run_decrypt_file(self, algorithm, mode, key, input_path, output_path, iv=None): - args = self._build_file_args( - algorithm, mode, key, input_path, output_path, iv) + args = self._build_file_args(algorithm, mode, key, input_path, output_path, iv) return self.run(self._DECRYPT_FILE, args) -- cgit v1.3