samva 2.0.5__py3-none-any.whl

samva/__init__.py

@@ -0,0 +1,15 @@
+# SAMVA, initial software
+# Copyright © INRIA, Affero GPL v3, 2022, v 1.0
+
+__all__ = [
+    "commands",
+    "core",
+    "evaluator",
+    "experimentation",
+    "physical",
+    "plot"
+]
+
+"""
+.. include:: ../../README.md
+"""

samva/__main__.py

@@ -0,0 +1,7 @@
+# SAMVA, initial software
+# Copyright © INRIA, Affero GPL v3, 2022, v 1.0
+
+from .cli import main
+
+if __name__ == "__main__":
+    main()

samva/cli.py

@@ -0,0 +1,167 @@
+# SAMVA, initial software
+# Copyright © INRIA, Affero GPL v3, 2022, v 1.0
+import pyghidra
+import click
+
+pyghidra.start()
+
+import logging  # noqa: E402
+from functools import partial  # noqa: E402
+from samva.commands.evaluate import run_evaluate  # noqa: E402
+from samva.commands.cv32e40p import run_cv32e40p  # noqa: E402
+from samva.commands.debugger import run_debugger  # noqa: E402
+from samva.commands.traitor import run_traitor, run_traitor_characterization  # noqa: E402
+from samva.commands.stm32 import run_stm32  # noqa: E402
+from samva.commands.measure_cycles import run_measure_cycles  # noqa: E402
+from samva.commands.test_dynprog import run_test_dynprog  # noqa: E402
+
+log = logging.getLogger(name=f"samva-{__name__}")
+log.setLevel(logging.DEBUG)
+
+
+# @click.group()
+@click.group(chain=True)
+def main():
+    pass
+
+@main.command()
+# Mandatory arguments
+@click.argument("bin_path", required=True, type=click.Path(exists=True, file_okay=True, writable=False))
+@click.argument("samva_config_path", required=True, type=click.Path(exists=True, file_okay=True, writable=False))
+# Most common options, comes with reasonable default values
+@click.option("--result_folder", required=False, type=click.Path(exists=True, file_okay=False, writable=True), help="Directory where the results are stored.")
+@click.option("--fault_model", required=False, type=click.Choice(["TrueNOP", "Replay"], case_sensitive=False), default="TrueNOP")
+@click.option("--fault_parameters", required=False, type=(int, int, int), default=(1, 10, 1), help="Specify the fault model as argument if not in configuration file.")
+# Options related to new algorithms
+@click.option("--max_paths_per_segment", required=False, type=int, default=None, help="Maximum number of paths to find for each attack segment.")
+@click.option("--max_cost_per_segment", required=False, type=int, default=None, help="Maximum number of faults allowed in each attack segment.")
+@click.option("--max_cost_for_simulation", required=False, type=int, default=None, help="Maximum number of faults considered for simulation.")
+@click.option("--max_attack_paths", required=False, type=int, default=None, help="Maximum number of attack paths to find.")
+# Options related to attack paths evaluation
+@click.option("--evaluator", type=click.Choice(["unicorn", "gem5", "none"], case_sensitive=False), default="unicorn", help="Evaluator used to validate the attack paths.")
+@click.option("--unicorn_full_init/--no-unicorn_full_init", default=True, help="Specific to unicorn emulation. PC is set to first attacked address, without running the full program init to avoid impossible loop due hardware interactions.")
+@click.option("--log_variable", "-lv", multiple=True, help="Program symbols that will be logged during evaluation.")
+# Options enabling early exit
+@click.option("--timeout", required=False, type=float, default=-1.0, help="Analysis timeout.")
+@click.option("--stop_at_robustness/--no_stop_at_robustness", default=True, help="Stop after finding the robustness factor.")
+# Options that enable the previous algorithms, for compatibility purposes
+@click.option("--deprecated/--no_deprecated", required=False, type=bool, default=False, help="Enable previous algorithms.")
+@click.option("--deprecated_exhaustive/--no-deprecated_exhaustive", required=False, type=bool, default=False, help="Enable exhaustive search for backtracking fault positioning.")
+@click.option("--deprecated_max_solutions", required=False, type=int, default=5, help="Maximum number of solutions found per attack path.")
+# Verbose mode, useful for debug.
+@click.option("--verbose/--no-verbose", default=False, help="Displays information during the analysis.")
+def evaluate(bin_path, samva_config_path, result_folder, fault_model,
+                 fault_parameters, max_paths_per_segment, max_cost_per_segment, max_cost_for_simulation,
+                 max_attack_paths, evaluator, unicorn_full_init, log_variable, timeout, stop_at_robustness,
+                 deprecated, deprecated_exhaustive, deprecated_max_solutions, verbose):
+    return partial(run_evaluate, bin_path=bin_path, samva_config_path=samva_config_path, result_folder=result_folder,
+                   fault_model=fault_model, fault_parameters=fault_parameters,
+                   max_paths_per_segment=max_paths_per_segment, max_cost_per_segment=max_cost_per_segment,
+                   max_cost_for_simulation=max_cost_for_simulation, max_attack_paths=max_attack_paths,
+                   evaluator=evaluator, unicorn_full_init=unicorn_full_init, log_variable=log_variable,
+                   timeout=timeout, stop_at_robustness=stop_at_robustness, deprecated=deprecated,
+                   deprecated_exhaustive=deprecated_exhaustive, deprecated_max_solutions=deprecated_max_solutions,
+                   verbose=verbose)
+
+@main.command()
+@click.argument("port", required=True)
+@click.option("--verbose/--no-verbose", default=False, help="Displays information during the analysis.")
+def cv32e40p(port, verbose):
+    return partial(run_cv32e40p, port=port, verbose=verbose)
+
+@main.command()
+@click.option("--verbose/--no-verbose", default=False, help="Displays information during the analysis.")
+def debugger(verbose):
+    return partial(run_debugger, verbose=verbose)
+
+@main.command()
+@click.argument("port", required=True)
+@click.option("--traitor_amplitude", "-ta", type=int, multiple=True, help="Traitor amplitude used during the attacks.")
+@click.option("--traitor_fault", "-tf", type=(int, int), multiple=True, help="Traitor fault <delay, duration> parameter.")
+@click.option("--reset/--no-reset", default=False, help="Reset Traitor configuration.")
+@click.option("--repetitions", required=False, type=int, default=5, help="Number of attack per configuration tested.")
+@click.option("--campaign/--no-campaign", default=False, help="Launch a Traitor campaign.")
+@click.option("--verbose/--no-verbose", default=False, help="Displays information during the analysis.")
+def traitor(port, traitor_amplitude, traitor_fault, reset, repetitions, campaign, verbose):
+    return partial(run_traitor, port=port, amplitudes=traitor_amplitude, temporal_parameters=traitor_fault, reset=reset,
+                   repetitions=repetitions, campaign=campaign, verbose=verbose)
+
+@main.command()
+@click.option('--custom_port', default=None, type=str)
+@click.option('--stlink', default=None, type=str)
+@click.option('--program', default=None, type=str)
+@click.option("--verbose/--no-verbose", default=False, help="Displays information during the analysis.")
+def stm32(custom_port, stlink, program, verbose):
+    return partial(run_stm32, custom_port=custom_port, stlink=stlink, program=program, verbose=verbose)
+
+@main.command()
+@click.argument("addr1", type=str)
+@click.argument("addr2", type=str)
+@click.option("--verbose/--no-verbose", default=False, help="Displays information during the analysis.")
+def measure_cycles(addr1, addr2, verbose):
+    return partial(run_measure_cycles, addr1=addr1, addr2=addr2, verbose=verbose)
+
+@main.command()
+@click.option('--trace', type=str, help="Complete trace.")
+@click.option('--seed', type=int, help="Random seed; if 0, unseeded.", default=0)
+@click.option('--length', type=int, help="Length of the generated trace.")
+@click.option('--repeats', type=int, help="Number of traces to generate.")
+@click.option('--fault_parameters', type=(int, int, int), help="Specify the fault model as argument if not in "
+                                                               "configuration file.")
+@click.option('--max_solutions', required=False, type=int, default=100)
+@click.option('--exhaustive/--no-exhaustive', required=False, type=bool, default=False)
+@click.option('--verbose/--no-verbose', default=False, help="Displays information during the core.")
+def test_dynprog(trace, seed, length, repeats, fault_parameters, max_solutions, exhaustive, verbose):
+    return partial(run_test_dynprog, trace=trace, seed=seed, length=length, repeats=repeats,
+                   fault_parameters=fault_parameters, max_solutions=max_solutions, exhaustive=exhaustive,
+                   verbose=verbose)
+
+@main.command()
+@click.argument("port", required=True)
+@click.option('--amplitude_range', type=(int, int), required=True)
+@click.option('--delay_range', type=(int, int), required=True)
+@click.option('--duration_range', type=(int, int), required=True)
+@click.option("--repetitions", required=False, type=int, default=50, help="Number of attack per configuration tested.")
+@click.option("--amplitude_step", required=False, type=int, default=1)
+@click.option("--delay_step", required=False, type=int, default=1)
+@click.option("--duration_step", required=False, type=int, default=1)
+@click.option('--verbose/--no-verbose', default=False, help="Displays information during the core.")
+def traitor_characterization(port, amplitude_range, delay_range, duration_range, repetitions, amplitude_step,
+                             delay_step, duration_step, verbose):
+    return partial (run_traitor_characterization, port=port, amplitude_range=amplitude_range, delay_range=delay_range,
+                    duration_range=duration_range, repetitions=repetitions, amplitude_step=amplitude_step,
+                    delay_step=delay_step, duration_step=duration_step, verbose=verbose)
+
+
+# TODO: must integrate the other commands with the new chaining command system
+# # STM32 commands
+# main.add_command(stm32.simulate, "simulate")
+#
+# # Plotting commands
+# main.add_command(plot.plot_faulting_delays, "plot_faulting_delays")  # amplitude = f(burst_size)
+# main.add_command(plot.plot_amp_delay, "plot_amp_delay")  # amplitude = f(burst_size)
+# main.add_command(plot.plot_histo_classification, "plot_histo_classification")  # fault classification for each delay
+# main.add_command(plot.plot_histo_classification2, "plot_histo_classification2")  # for each delay histo(amplitude)
+# main.add_command(plot.plot_number_difference, "plot_number_difference")  # 3D plot amplitude = f(duration, delay)
+#
+# # Evaluation commands for SAMVA v2
+# main.add_command(evals.eval_verifypin_truenop, "eval_verifypin_truenop")
+
+
+@main.result_callback()
+def process_pipeline(processors):
+    value = None
+    for processor in processors:
+        value = processor(value)
+
+    if value is not None and type(value) is dict:
+        for binary_name in value.keys():
+            if "log" in value[binary_name] and len(value[binary_name]["log"]) > 0:
+                log.info("")
+                log.info("")
+                log.info("--- SAMVA Log Summary ---")
+                for line in value[binary_name]["log"]:
+                    log.info(line)
+
+if __name__ == '__main__':
+    main()

samva/commands/__init__.py

@@ -0,0 +1,6 @@
+# SAMVA, initial software
+# Copyright © INRIA, Affero GPL v3, 2022, v 1.0
+
+"""
+commands module contains the integrated commands shipped with SAMVA.
+"""

samva/commands/commands_common.py

@@ -0,0 +1,107 @@
+# SAMVA, initial software
+# Copyright © INRIA, Affero GPL v3, 2022, v 1.0
+
+import ast
+import logging
+from functools import wraps
+
+import click
+
+from samva.core.common import setup_logging
+from samva.core.common.analysis_utils import Timing
+
+log = logging.getLogger(name=f"samva-{__name__}")
+log.setLevel(logging.DEBUG)
+
+
+class BasedIntParamType(click.ParamType):
+    name = "integer"
+
+    def convert(self, value, param, ctx):
+        if isinstance(value, int):
+            return value
+
+        try:
+            if value[:2].lower() == "0x":
+                return int(value[2:], 16)
+            elif value[:1] == "0":
+                return int(value, 8)
+            return int(value, 10)
+        except ValueError:
+            self.fail(f"{value!r} is not a valid integer", param, ctx)
+
+BASED_INT = BasedIntParamType()
+
+class PythonLiteralOption(click.Option):
+
+    def type_cast_value(self, ctx, value):
+        if value is None:
+            return None
+        try:
+            return ast.literal_eval(value)
+        except:
+            raise click.BadParameter(value)
+
+# Decorators
+
+def check_logging(command):
+    @wraps(command)
+    def wrapper(*args, **kwargs):
+        verbose = kwargs.get("verbose", False)
+        setup_logging(logging.DEBUG if verbose else logging.INFO)
+        return command(*args, **kwargs)
+    return wrapper
+
+def must_be_chained(required: bool):
+    def decorator(command):
+        @wraps(command)
+        def wrapper(previous, *args, **kwargs):
+            if required and previous is None:
+                command_name = command.__name__
+                if command_name.startswith("run_"):
+                    command_name = command_name[4:]
+                raise RuntimeError(f"\"{command_name}\" command must be chained after another command.")
+            return command(previous if previous is not None else {}, *args, **kwargs)
+        return wrapper
+    return decorator
+
+def hardware_attack(command):
+    @wraps(command)
+    def wrapper(previous, *args, **kwargs):
+        for binary_name, result in previous.items():
+            create_target = result.get("create_target")
+            if create_target is None:
+                log.error(f"No hardware target for {binary_name}")
+                continue
+
+            target = create_target()
+
+            with Timing() as t_attack:
+                attack_tested, attack_validated = command(
+                    previous,
+                    target=target,
+                    binary_name=binary_name,
+                    *args,
+                    **kwargs,
+                )
+            duration = t_attack.time
+
+            result["hardware_result"] = {
+                "attack_path_tested": attack_tested,
+                "attack_path_validated": attack_validated,
+                "duration_sec": duration,
+            }
+
+            if attack_tested == 0:
+                txt = "No attack path tested due to previous error."
+            else:
+                txt = (
+                    f"Hardware validation - Validated {attack_validated} / "
+                    f"{attack_tested} in {duration:.2f} seconds "
+                    f"(mean of {duration / attack_tested:.2f} secs)."
+                )
+
+            log.info(txt)
+            result["log"].append(txt)
+        return previous
+    return wrapper

samva/commands/commands_evals.py

@@ -0,0 +1,92 @@
+import logging
+import click
+import os
+
+from samva.experimentation import Benchmark, BenchmarkIterator
+from samva.core import Samva
+from samva.evaluator import EvaluatorBase
+from samva.evaluator.evaluator_unicorn2 import EvaluatorSimulationUnicorn2
+from samva.core.common.log_utils import setup_logging
+from samva.core.common.attack_path import FaultParameters, FaultModel
+from samva.core.common.analysis_utils import Timing
+
+
+log = logging.getLogger(name=f"samva-{__name__}")
+log.setLevel(logging.DEBUG)
+
+
+# @click.option('--fault_parameters', type=(int, int, int))
+# @click.option('--fault_model', type=click.Choice(['TrueNOP', 'Replay'], case_sensitive=False), default="TrueNOP")
+
+def path_verifyPIN(benchmark_folder, n, flags=""):
+    flags = "_" + flags if flags else ""
+    elf = os.path.join(benchmark_folder, f"build/verifypin_v{n}_cv32e40p/verifypin_v{n}_cv32e40p{flags}.elf")
+    config = os.path.join(benchmark_folder, f"samva_files/verifypin_v{n}_cv32e40p.json")
+    return elf, config
+
+@click.command()
+@click.option("--benchmark_folder", default="../samva_benchmarks")
+@click.option('--verbose/--no-verbose', default=False, help="Displays information during the core.")
+def eval_verifypin_truenop(benchmark_folder, verbose):
+    setup_logging(logging_level=logging.DEBUG if verbose else logging.INFO)
+
+    # Fixed settings
+    fault_model = FaultModel.TrueNOP
+    strategy = "default"
+    # Won't apply to the new algorithms
+    exhaustive = False
+    fake_timeout = 999999
+
+    samvas = dict()
+    evaluators = dict()
+
+    verifypin_versions = [0, 1, 2, 3, 4, 5, 6, 7]
+    # verifypin_versions = [5]
+
+    #=== Load programs ===#
+
+    for n in verifypin_versions:
+        path_elf, path_config = path_verifyPIN(benchmark_folder, n)
+
+        samvas[n] = Samva(path_elf, config_file=path_config, fault_model=fault_model, strategy=strategy,
+                          exhaustive=exhaustive)
+        evaluators[n] = EvaluatorSimulationUnicorn2(samvas[n].samva_model, fault_model)
+
+    #=== Run tests ===#
+
+    def attacks_within_time(n, timeout: float) -> int:
+        fault_parameters = FaultParameters(1, 4, 1, fake_timeout)
+        attack_result = samvas[n].find_data_aware_attack_paths(fault_parameters, evaluators[n],
+            max_paths_per_segment=None, max_cost_per_segment=None, max_cost_for_simulation=None,
+            stop_when_robustness_found=False, timeout=timeout)
+        attacks_found = len(attack_result.attack_paths or [])
+        print(f"Listed {attacks_found} attacks in {timeout} seconds")
+        return attacks_found
+
+    def robustness_map(fp, ns, low_width: int, high_width: int, min_distance: int, max_budget: int, timeout: floats) \
+            -> list[list[int]]:
+        fp.write(f"version,min_width,max_width,robustness,analysis_time\n")
+        fp.flush()
+        for n in ns:
+            for max_width in range(low_width, high_width + 1):
+                for min_width in range(low_width, max_width + 1):
+                    fault_parameters = FaultParameters(min_width, max_width, min_distance, fake_timeout)
+                    print(f"verifyPIN_v{n}: ({min_width}, {max_width}, {min_distance})...")
+                    with Timing() as t_analysis:
+                        attack_result = samvas[n].find_data_aware_attack_paths(fault_parameters, evaluators[n],
+                            max_paths_per_segment=None, max_cost_per_segment=max_budget, max_cost_for_simulation=None,
+                            stop_when_robustness_found=True, timeout=timeout)
+
+                    if attack_result.robustness is not None:
+                        robustness = str(attack_result.robustness)
+                    elif samvas[n].bound_min_attacks is None:
+                        robustness = "+inf"
+                    else:
+                        robustness = f">= {samvas[n].bound_min_attacks - 1}"
+
+                    print(f"verifyPIN_v{n}: ({min_width}, {max_width}, {min_distance}) -> {robustness} in {t_analysis}")
+                    fp.write(f"{n},{min_width},{max_width},{robustness},{t_analysis.time}\n")
+                    fp.flush()
+
+    with open("verifypin_truenop_robustness.csv", "w") as fp:
+        robustness_map(fp, verifypin_versions, 1, 10, 1, max_budget=None, timeout=30.0)

samva/commands/commands_plot.py

@@ -0,0 +1,68 @@
+# SAMVA, initial software
+# Copyright © INRIA, Affero GPL v3, 2022, v 1.0
+
+import os
+
+import click
+
+@click.command()
+@click.argument('input_file', required=1, type=str)
+@click.argument('output_file', required=0, type=str, default=None)
+@click.option('--tex', default=False)
+def plot_faulting_delays(input_file, output_file, tex):
+    from samva.plot.faulting_delays import faulting_delays
+    if output_file is None:
+        path_split = os.path.splitext(input_file)
+        output_file = path_split[0] + "_delays.pdf"
+    faulting_delays(input_file, output_file, tex)
+
+@click.command()
+@click.argument('input_file', required=1, type=str)
+@click.argument('output_file', required=0, type=str, default=None)
+@click.argument('fault', required=1, type=str)
+@click.option('--tex', default=False)
+def plot_amp_delay(input_file, output_file, fault, tex):
+    from samva.plot.histo_amp_delay import faulting_ampdelay
+    faulting_ampdelay(input_file, output_file, fault, tex)
+
+
+@click.command()
+@click.argument('input_file', required=1, type=str)
+@click.argument('output_file', required=0, type=str, default=None)
+@click.argument('delay_value', required=1, type=int)
+@click.option('--tex', default=False)
+def plot_histo_classification(input_file, output_file, delay_value, tex):
+    if output_file is None:
+        path_split = os.path.splitext(input_file)
+        output_file = path_split[0] + "_hist.pdf"
+    from samva.plot.histo_classification import histo_classification
+    histo_classification(input_file, output_file, delay_value, tex)
+
+
+@click.command()
+@click.argument('input_file', required=1, type=str)
+@click.argument('output_file', required=0, type=str, default=None)
+@click.option('--others_perc', type=int, default=5)
+@click.option('--percentage', default=False)
+@click.option('--duration_group', default=False)
+@click.option('--duration_group_value', type=int, default=4)
+@click.option('--tex', default=False)
+def plot_histo_classification2(input_file, output_file, others_perc, percentage, duration_group,
+                               duration_group_value, tex):
+    if output_file is None:
+        path_split = os.path.splitext(input_file)
+        output_file = path_split[0] + "_hist2.pdf"
+    from samva.plot.histo_classification2 import histo_classification2
+    histo_classification2(input_file, output_file, others_perc, percentage, duration_group, duration_group_value, tex)
+
+
+@click.command()
+@click.argument('input_file', required=1, type=str)
+@click.argument('output_file', required=0, type=str, default=None)
+@click.option('--tex', default=False)
+def plot_number_difference(input_file, output_file, tex):
+    if output_file is None:
+        path_split = os.path.splitext(input_file)
+        output_file = path_split[0] + "_numbdiff.pdf"
+    from samva.plot.number_difference import number_difference
+    number_difference(input_file, output_file, tex)