failure_test_utils.hpp

Go to the documentation of this file.

#pragma once
 
#include "barretenberg/ultra_honk/prover_instance.hpp"
#include <memory>
#include <unordered_map>
#include <utility>
 
namespace bb {
 
template <typename Flavor> class MaliciousWitnessInjector {
  public:
    using Builder = typename Flavor::CircuitBuilder;
    using FF = typename Flavor::FF;
    using ProverInstance = ProverInstance_<Flavor>;
 
    Builder builder;
 
  private:
    // Maps variable index to the "bad" value to be injected
    std::unordered_map<uint32_t, FF> malicious_variable_map;
 
  public:
    uint32_t add_malicious_variable(const FF& good_val, const FF& bad_val)
    {
        uint32_t idx = builder.add_variable(good_val);
        malicious_variable_map[idx] = bad_val;
        return idx;
    }
 
    std::pair<std::shared_ptr<ProverInstance>, std::shared_ptr<ProverInstance>> create_instances()
    {
        // Create good instance from original builder (this finalizes the circuit)
        auto good_instance = std::make_shared<ProverInstance>(builder);
 
        // Create bad instance
        Builder bad_builder = create_builder_with_malicious_witnesses();
        auto bad_instance = std::make_shared<ProverInstance>(bad_builder);
 
        return { good_instance, bad_instance };
    }
 
    Builder create_builder_with_malicious_witnesses()
    {
        // Copy the builder
        Builder bad_builder = builder;
 
        // Inject faults into the copied builder's variables
        auto& vars = const_cast<std::vector<FF>&>(bad_builder.get_variables());
        for (const auto& [var_idx, bad_val] : malicious_variable_map) {
            // Resolve through real_variable_index to handle copy constraints correctly
            uint32_t real_idx = bad_builder.real_variable_index[var_idx];
            vars[real_idx] = bad_val;
        }
 
        return bad_builder;
    }
};
 
} // namespace bb