mbedtls/tests/scripts/generate_psa_tests.py

#!/usr/bin/env python3
"""Generate test data for PSA cryptographic mechanisms.
"""

# Copyright The Mbed TLS Contributors
# SPDX-License-Identifier: Apache-2.0
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import argparse
import os
import re
import sys
from typing import Iterable, List, TypeVar

import scripts_path # pylint: disable=unused-import
from mbedtls_dev import crypto_knowledge
from mbedtls_dev import macro_collector
from mbedtls_dev import test_case

T = TypeVar('T') #pylint: disable=invalid-name


def test_case_for_key_type_not_supported(verb: str, key_type: str, bits: int,
                                         dependencies: List[str],
                                         *args: str) -> test_case.TestCase:
    """Return one test case exercising a key creation method
    for an unsupported key type or size.
    """
    tc = test_case.TestCase()
    adverb = 'not' if dependencies else 'never'
    tc.set_description('PSA {} {} {}-bit {} supported'
                       .format(verb, key_type, bits, adverb))
    tc.set_dependencies(dependencies)
    tc.set_function(verb + '_not_supported')
    tc.set_arguments([key_type] + list(args))
    return tc

class TestGenerator:
    """Gather information and generate test data."""

    def __init__(self, options):
        self.test_suite_directory = self.get_option(options, 'directory',
                                                    'tests/suites')
        self.constructors = self.read_psa_interface()

    @staticmethod
    def get_option(options, name: str, default: T) -> T:
        value = getattr(options, name, None)
        return default if value is None else value

    @staticmethod
    def remove_unwanted_macros(
            constructors: macro_collector.PSAMacroCollector
    ) -> None:
        # Mbed TLS doesn't support DSA. Don't attempt to generate any related
        # test case.
        constructors.key_types.discard('PSA_KEY_TYPE_DSA_KEY_PAIR')
        constructors.key_types.discard('PSA_KEY_TYPE_DSA_PUBLIC_KEY')
        constructors.algorithms_from_hash.pop('PSA_ALG_DSA', None)
        constructors.algorithms_from_hash.pop('PSA_ALG_DETERMINISTIC_DSA', None)

    def read_psa_interface(self) -> macro_collector.PSAMacroCollector:
        """Return the list of known key types, algorithms, etc."""
        constructors = macro_collector.PSAMacroCollector()
        header_file_names = ['include/psa/crypto_values.h',
                             'include/psa/crypto_extra.h']
        for header_file_name in header_file_names:
            with open(header_file_name, 'rb') as header_file:
                constructors.read_file(header_file)
        self.remove_unwanted_macros(constructors)
        return constructors

    def write_test_data_file(self, basename: str,
                             test_cases: Iterable[test_case.TestCase]) -> None:
        """Write the test cases to a .data file.

        The output file is ``basename + '.data'`` in the test suite directory.
        """
        filename = os.path.join(self.test_suite_directory, basename + '.data')
        test_case.write_data_file(filename, test_cases)

    @staticmethod
    def test_cases_for_key_type_not_supported(
            kt: crypto_knowledge.KeyType
    ) -> List[test_case.TestCase]:
        """Return test cases exercising key creation when the given type is unsupported."""
        if kt.name == 'PSA_KEY_TYPE_RAW_DATA':
            # This key type is always supported.
            return []
        want_symbol = re.sub(r'\APSA_', r'PSA_WANT_', kt.name)
        import_dependencies = ['!' + want_symbol]
        if kt.name.endswith('_PUBLIC_KEY'):
            generate_dependencies = []
        else:
            generate_dependencies = import_dependencies
        test_cases = []
        for bits in kt.sizes_to_test():
            test_cases.append(test_case_for_key_type_not_supported(
                'import', kt.name, bits, import_dependencies,
                test_case.hex_string(kt.key_material(bits))
            ))
            test_cases.append(test_case_for_key_type_not_supported(
                'generate', kt.name, bits, generate_dependencies,
                str(bits)
            ))
            # To be added: derive
        return test_cases

    def generate_not_supported(self) -> None:
        """Generate test cases that exercise the creation of keys of unsupported types."""
        test_cases = []
        for key_type in sorted(self.constructors.key_types):
            kt = crypto_knowledge.KeyType(key_type)
            test_cases += self.test_cases_for_key_type_not_supported(kt)
        # To be added: parametrized key types (ECC, FFDH)
        self.write_test_data_file(
            'test_suite_psa_crypto_not_supported.generated',
            test_cases)

    def generate_all(self):
        self.generate_not_supported()

def main(args):
    """Command line entry point."""
    parser = argparse.ArgumentParser(description=__doc__)
    options = parser.parse_args(args)
    generator = TestGenerator(options)
    generator.generate_all()

if __name__ == '__main__':
    main(sys.argv[1:])