mbedtls-framework/scripts/make_generated_files.py

#!/usr/bin/env python3

# make_generated_files.py
#
# Copyright The Mbed TLS Contributors
# SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later

"""
Generate the TF-PSA-Crypto generated files
"""
import argparse
import filecmp
import shutil
import subprocess
import sys

from pathlib import Path
from typing import List, Optional

from mbedtls_framework import build_tree

class GenerationScript:
    """
    Representation of a script generating a configuration independent file.
    """
    # pylint: disable=too-few-public-methods,too-many-arguments
    def __init__(self, script: Path, files: List[Path],
                 output_dir_option: Optional[str] = None,
                 output_file_option: Optional[str] = None,
                 optional: bool = False) -> None:
        # Path from the root of Mbed TLS or TF-PSA-Crypto of the generation script
        self.script = script

        # Executable to run the script, needed for Windows
        if script.suffix == ".py":
            self.exe = sys.executable
        elif script.suffix == ".pl":
            self.exe = "perl"

        # List of the default paths from the Mbed TLS or TF-PSA-Crypto root of the
        # files the script generates.
        self.files = files

        # Output directory script argument. Can be an empty string in case it is a
        # positional argument.
        self.output_dir_option = output_dir_option

        # Output file script argument. Can be an empty string in case it is a
        # positional argument.
        self.output_file_option = output_file_option

        # Optional files are skipped in --check mode if they don't exist.
        # This normally shouldn't happen, but it can happen during transition
        # periods where we're adding a new script or a new file, and a
        # consuming repository hasn't been updated yet.
        self.optional = optional

def get_generation_script_files(generation_script: str) -> List[Path]:
    """
    Get the list of the default paths of the files that a given script
    generates. It is assumed that the script supports the "--list" option.
    """
    files = []
    if generation_script.endswith(".py"):
        cmd = [sys.executable]
    elif generation_script.endswith(".pl"):
        cmd = ["perl"]
    cmd += [generation_script, "--list"]

    output = subprocess.check_output(cmd, universal_newlines=True)
    for line in output.splitlines():
        files.append(Path(line))

    return files

COMMON_GENERATION_SCRIPTS = [
    GenerationScript(
        Path("scripts/generate_config_checks.py"),
        get_generation_script_files("scripts/generate_config_checks.py"),
        output_dir_option="",
        optional=True)
]

if build_tree.looks_like_tf_psa_crypto_root("."):
    TF_PSA_CRYPTO_GENERATION_SCRIPTS = [
        GenerationScript(
            Path("scripts/generate_driver_wrappers.py"),
            [Path("core/psa_crypto_driver_wrappers.h"),
             Path("core/psa_crypto_driver_wrappers_no_static.c")],
            "", None
        ),
        GenerationScript(
            Path("framework/scripts/generate_test_keys.py"),
            [Path("tests/include/test/test_keys.h")],
            None, "--output"
        ),
        GenerationScript(
            Path("scripts/generate_psa_constants.py"),
            [Path("programs/psa/psa_constant_names_generated.c")],
            "", None
        ),
        GenerationScript(
            Path("framework/scripts/generate_bignum_tests.py"),
            get_generation_script_files("framework/scripts/generate_bignum_tests.py"),
            "--directory", None
        ),
        GenerationScript(
            Path("framework/scripts/generate_config_tests.py"),
            get_generation_script_files("framework/scripts/generate_config_tests.py"),
            "--directory", None
        ),
        GenerationScript(
            Path("framework/scripts/generate_ecp_tests.py"),
            get_generation_script_files("framework/scripts/generate_ecp_tests.py"),
            "--directory", None
        ),
        GenerationScript(
            Path("framework/scripts/generate_psa_tests.py"),
            get_generation_script_files("framework/scripts/generate_psa_tests.py"),
            "--directory", None
        ),
    ]


if build_tree.looks_like_mbedtls_root(".") and not build_tree.is_mbedtls_3_6():
    MBEDTLS_GENERATION_SCRIPTS = [
        GenerationScript(
            Path("scripts/generate_errors.pl"),
            [Path("library/error.c")],
            None, "tf-psa-crypto/drivers/builtin/include/mbedtls \
                   include/mbedtls/ \
                   scripts/data_files"
        ),
        GenerationScript(
            Path("scripts/generate_features.pl"),
            [Path("library/version_features.c")],
            None, "include/mbedtls/ scripts/data_files"
        ),
        GenerationScript(
            Path("framework/scripts/generate_ssl_debug_helpers.py"),
            [Path("library/ssl_debug_helpers_generated.c")],
            "", None
        ),
        GenerationScript(
            Path("framework/scripts/generate_test_keys.py"),
            [Path("tests/include/test/test_keys.h")],
            None, "--output"
        ),
        GenerationScript(
            Path("framework/scripts/generate_test_cert_macros.py"),
            [Path("tests/include/test/test_certs.h")],
            None, "--output"
        ),
        GenerationScript(
            Path("scripts/generate_query_config.pl"),
            [Path("programs/test/query_config.c")],
            None, "include/mbedtls/mbedtls_config.h \
                   tf-psa-crypto/include/psa/crypto_config.h \
                   scripts/data_files/query_config.fmt"
        ),
        GenerationScript(
            Path("framework/scripts/generate_config_tests.py"),
            get_generation_script_files("framework/scripts/generate_config_tests.py"),
            "--directory", None
        ),
        GenerationScript(
            Path("framework/scripts/generate_tls13_compat_tests.py"),
            [Path("tests/opt-testcases/tls13-compat.sh")],
            None, "--output"
        ),
        GenerationScript(
            Path("framework/scripts/generate_tls_handshake_tests.py"),
            [Path("tests/opt-testcases/handshake-generated.sh")],
            None, "--output"
        ),
    ]

    if Path("scripts/generate_visualc_files.pl").is_file():
        MBEDTLS_GENERATION_SCRIPTS.append(
            GenerationScript(
                Path("scripts/generate_visualc_files.pl"),
                get_generation_script_files("scripts/generate_visualc_files.pl"),
                "--directory", None))

def get_generated_files(generation_scripts: List[GenerationScript]) -> List[Path]:
    """
    List the generated files in Mbed TLS or TF-PSA-Crypto. The path from root
    is returned for each generated files.
    """
    files = []
    for generation_script in generation_scripts:
        files += generation_script.files

    return files

def make_generated_files(generation_scripts: List[GenerationScript]) -> None:
    """
    Generate the configuration independent files in their default location in
    the Mbed TLS or TF-PSA-Crypto tree.
    """
    for generation_script in generation_scripts:
        subprocess.run([generation_script.exe, str(generation_script.script)], check=True)

def check_generated_files(generation_scripts: List[GenerationScript],
                          root: Path) -> bool:
    """
    Check that the given root directory contains the generated files as expected/
    generated by this script.
    """
    ok = True
    for generation_script in generation_scripts:
        for file in generation_script.files:
            file = root / file
            if not file.exists():
                # If the script is just being added, allow its files not
                # to exist. This can happen, at least, when adding a new
                # generation script in crypto: until mbedtls is updated,
                # the files from that script won't be present when
                # the updated crypto is built from mbedtls development.
                if generation_script.optional:
                    continue
                raise Exception(f"Expected generated file does not exist: {file}")
            bak_file = file.with_name(file.name + ".bak")
            if bak_file.exists():
                bak_file.unlink()
            file.rename(bak_file)

        command = [generation_script.exe, str(generation_script.script)]
        if generation_script.output_dir_option is not None:
            command += [generation_script.output_dir_option,
                        str(root / Path(generation_script.files[0].parent))]
        elif generation_script.output_file_option is not None:
            command += generation_script.output_file_option.split()
            command += [str(root / Path(generation_script.files[0]))]
        subprocess.run([item for item in command if item.strip()], check=True)

        for file in generation_script.files:
            file = root / file
            bak_file = file.with_name(file.name + ".bak")
            if generation_script.optional and not bak_file.exists():
                # This file is optional and didn't exist before, so
                # there's nothing to compare to, or clean up.
                continue
            if not filecmp.cmp(file, bak_file):
                ok = False
                ref_file = file.with_name(file.name + ".ref")
                ref_file = root / ref_file
                if ref_file.exists():
                    ref_file.unlink()
                shutil.copy(file, ref_file)
                print(f"Generated file {file} not identical to the reference one {ref_file}.")
            file.unlink()
            bak_file.rename(file)
    return ok

def main() -> int:
    """
    Main function of this program
    """
    parser = argparse.ArgumentParser()

    parser.add_argument('--list', action='store_true',
                        default=False, help='List generated files.')
    parser.add_argument('--root', metavar='DIR',
                        help='Root of the tree containing the generated files \
                              to check (default: Mbed TLS or TF-PSA-Cryto root.)')
    parser.add_argument('--check', action='store_true',
                        default=False, help='Check the generated files in root')

    args = parser.parse_args()

    if not build_tree.looks_like_root("."):
        raise RuntimeError("This script must be run from Mbed TLS or TF-PSA-Crypto root.")

    if build_tree.looks_like_tf_psa_crypto_root("."):
        generation_scripts = TF_PSA_CRYPTO_GENERATION_SCRIPTS
    elif not build_tree.is_mbedtls_3_6():
        generation_scripts = MBEDTLS_GENERATION_SCRIPTS
    else:
        raise Exception("No support for Mbed TLS 3.6")
    generation_scripts += COMMON_GENERATION_SCRIPTS

    if args.list:
        files = get_generated_files(generation_scripts)
        for file in files:
            print(str(file))
        return 0
    elif args.check:
        ok = check_generated_files(generation_scripts, Path(args.root or "."))
        return 0 if ok else 1
    else:
        make_generated_files(generation_scripts)
        return 0 # Any error causes an exception

if __name__ == "__main__":
    sys.exit(main())