functional_candidate.h

Go to the documentation of this file.

// MIT License
//
// Copyright (c) 2019 Ruhr University Bochum, Chair for Embedded Security. All Rights reserved.
// Copyright (c) 2019 Marc Fyrbiak, Sebastian Wallat, Max Hoffmann ("ORIGINAL AUTHORS"). All rights reserved.
// Copyright (c) 2021 Max Planck Institute for Security and Privacy. All Rights reserved.
// Copyright (c) 2021 Jörn Langheinrich, Julian Speith, Nils Albartus, René Walendy, Simon Klix ("ORIGINAL AUTHORS"). All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
 
#pragma once
 
#include "hal_core/defines.h"
#include "hal_core/netlist/gate.h"
#include "module_identification/candidates/candidate_context.h"
#include "module_identification/candidates/structural_candidate.h"
#include "module_identification/candidates/verified_candidate.h"
 
namespace hal
{
    namespace module_identification
    {
        class FunctionalCandidate
        {
        public:
            FunctionalCandidate(StructuralCandidate* sc, u32 max_control_signal, module_identification::CandidateType candidate_type);
 
            static hal::Result<std::vector<FunctionalCandidate>> create_candidates(StructuralCandidate* sc,
                                                                                   u32 max_control_signal,
                                                                                   CandidateContext& ctx,
                                                                                   module_identification::CandidateType candidate_type,
                                                                                   const std::vector<std::vector<Gate*>>& registers);
 
            // Comparisons
 
            static hal::Result<std::vector<FunctionalCandidate>> find_control_signals(CandidateContext& ctx, const FunctionalCandidate& candidate);
 
            static hal::Result<std::vector<FunctionalCandidate>> order_input_operands(CandidateContext& ctx, const FunctionalCandidate& candidate);
 
            static hal::Result<std::vector<FunctionalCandidate>> discard_equal_candidate(CandidateContext& ctx, const FunctionalCandidate& candidate);
 
            static hal::Result<std::vector<FunctionalCandidate>> trim_to_single_output_net(CandidateContext& ctx, const FunctionalCandidate& candidate);
 
            static hal::Result<std::vector<FunctionalCandidate>> create_sign_extension_variants(CandidateContext& ctx, const FunctionalCandidate& candidate);
 
            // Adder, subtractor, counter
 
            static hal::Result<std::vector<FunctionalCandidate>> identify_control_signals(CandidateContext& ctx, const FunctionalCandidate& candidate);
 
            static hal::Result<std::vector<FunctionalCandidate>> realize_control_signals(CandidateContext& ctx, const FunctionalCandidate& candidate);
 
            static hal::Result<std::vector<FunctionalCandidate>> update_input_output_stats(CandidateContext& ctx, const FunctionalCandidate& candidate);
 
            static hal::Result<std::vector<FunctionalCandidate>> permute_single_input_signals(CandidateContext& ctx, const FunctionalCandidate& candidate);
 
            static hal::Result<std::vector<FunctionalCandidate>> build_input_operands(CandidateContext& ctx, const FunctionalCandidate& candidate);
 
            static hal::Result<std::vector<FunctionalCandidate>> order_output_signals(CandidateContext& ctx, const FunctionalCandidate& candidate);
 
            static hal::Result<std::vector<FunctionalCandidate>> create_sign_bit_variants(CandidateContext& ctx, const FunctionalCandidate& candidate);
 
            static hal::Result<std::vector<FunctionalCandidate>> create_input_extension_variants(CandidateContext& ctx, const FunctionalCandidate& candidate);
 
            static hal::Result<std::vector<FunctionalCandidate>> create_output_net_variant(CandidateContext& ctx, const FunctionalCandidate& candidate);
 
            static hal::Result<std::vector<FunctionalCandidate>> add_single_input_signals(CandidateContext& ctx, const FunctionalCandidate& candidate);
 
            static hal::Result<std::vector<FunctionalCandidate>> early_abort(CandidateContext& ctx, const FunctionalCandidate& candidate);
 
            // Absolute
 
            static hal::Result<std::vector<FunctionalCandidate>> create_operand_control_variations(CandidateContext& ctx, const FunctionalCandidate& candidate);
 
            // Constant Multiplication
 
            static FunctionalCandidate add_n_shifted_operands(const FunctionalCandidate& candidate, const std::vector<i32>& shift_vals);
 
            static hal::Result<std::vector<FunctionalCandidate>> add_selected_shifted_operand(CandidateContext& ctx, const FunctionalCandidate& candidate);
 
            static hal::Result<std::vector<FunctionalCandidate>> add_all_shifted_operand(CandidateContext& ctx, const FunctionalCandidate& candidate);
 
            // Value check
 
            static hal::Result<std::vector<FunctionalCandidate>> check_output_size(CandidateContext& ctx, const FunctionalCandidate& candidate);
 
            static hal::Result<std::vector<FunctionalCandidate>> build_input_operand(CandidateContext& ctx, const FunctionalCandidate& candidate);
 
            hal::Result<VerifiedCandidate> check(const std::vector<BooleanFunction>& output_functions, const std::vector<std::vector<Gate*>>& registers);
 
            void add_additional_data(std::string key, std::string value);
 
            std::map<std::string, std::string> get_all_additional_data() const;
 
            std::string get_candidate_info() const;
 
            module_identification::CandidateType m_candidate_type;
 
            std::vector<Gate*> m_gates;
 
            std::vector<Gate*> m_base_gates;
 
            StructuralCandidate* m_structural_candidate;
 
            std::vector<std::vector<Net*>> m_operands;
 
            std::vector<Net*> m_control_signals;
 
            std::map<Net*, BooleanFunction::Value> m_control_mapping;
 
            std::map<u32, std::vector<Net*>> m_influence_count_to_input_nets;
 
            std::map<u32, std::vector<Net*>> m_input_count_to_output_nets;
 
            std::map<Net*, Net*> m_single_input_to_output;
 
            std::vector<std::pair<Net*, Net*>> m_permuted_single_pairs;
 
            std::vector<Net*> m_input_nets;
 
            std::vector<Net*> m_output_nets;
 
            u32 m_max_control_signals;
 
            u32 m_max_operands;
 
            std::map<std::string, std::string> m_additional_data = {};
 
            Net* m_ctrl_to_operand_net;
 
            std::vector<Net*> m_sign_nets;
 
            std::map<std::string, std::map<std::string, std::map<std::string, std::map<std::string, u64>>>> m_timings;
        };
    }    // namespace module_identification
}    // namespace hal