party.h

Go to the documentation of this file.

// MIT License
//
// Copyright (c) 2021 Oleksandr Tkachenko, Arianne Roselina Prananto
// Cryptography and Privacy Engineering Group (ENCRYPTO)
// TU Darmstadt, Germany
//
// 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 <fmt/format.h>
#include <memory>
#include <span>
#include <vector>
 
#include "base/backend.h"
#include "base/configuration.h"
#include "protocols/arithmetic_gmw/arithmetic_gmw_share.h"
#include "protocols/arithmetic_gmw/arithmetic_gmw_wire.h"
#include "protocols/boolean_gmw/boolean_gmw_share.h"
#include "protocols/boolean_gmw/boolean_gmw_wire.h"
#include "protocols/share.h"
#include "utility/typedefs.h"
 
namespace encrypto::motion::communication {
 
class CommunicationLayer;
 
}  // namespace encrypto::motion::communication
 
namespace encrypto::motion {
 
class Logger;
 
class Party {
 public:
  Party() = delete;
 
  // Let's make only Configuration be copyable
  Party(Party& party) = delete;
 
  Party(std::unique_ptr<communication::CommunicationLayer> parties);
 
  ~Party();
 
  ConfigurationPointer GetConfiguration() { return configuration_; }
 
  communication::CommunicationLayer& GetCommunicationLayer() { return *communication_layer_; }
 
  template <MpcProtocol P>
  SharePointer In(std::span<const BitVector<>> input,
                  std::size_t party_id = std::numeric_limits<std::size_t>::max()) {
    static_assert(P != MpcProtocol::kArithmeticGmw);
    static_assert(P != MpcProtocol::kArithmeticConstant);
    switch (P) {
      case MpcProtocol::kBooleanConstant: {
        // TODO implement
        static_assert(P != MpcProtocol::kBooleanConstant, "Not implemented yet");
        // return backend_->BooleanGmwInput(party_id, input);
      }
      case MpcProtocol::kBooleanGmw: {
        return backend_->BooleanGmwInput(party_id, input);
      }
      case MpcProtocol::kBmr: {
        return backend_->BmrInput(party_id, input);
      }
      default: {
        throw(std::runtime_error(
            fmt::format("Unknown MPC protocol with id {}", static_cast<unsigned int>(P))));
      }
    }
  }
 
  template <MpcProtocol P>
  SharePointer In(std::vector<BitVector<>>&& input,
                  std::size_t party_id = std::numeric_limits<std::size_t>::max()) {
    static_assert(P != MpcProtocol::kArithmeticGmw);
    static_assert(P != MpcProtocol::kArithmeticConstant);
    switch (P) {
      case MpcProtocol::kBooleanConstant: {
        // TODO implement
        static_assert(P != MpcProtocol::kBooleanConstant, "Not implemented yet");
        // return backend_->BooleanGmwInput(party_id, input);
      }
      case MpcProtocol::kBooleanGmw: {
        return backend_->BooleanGmwInput(party_id, std::move(input));
      }
      case MpcProtocol::kBmr: {
        return backend_->BmrInput(party_id, input);
      }
      default: {
        throw(std::runtime_error(
            fmt::format("Unknown MPC protocol with id {}", static_cast<unsigned int>(P))));
      }
    }
  }
 
  template <MpcProtocol P>
  SharePointer In(const BitVector<>& input,
                  std::size_t party_id = std::numeric_limits<std::size_t>::max()) {
    static_assert(P != MpcProtocol::kArithmeticGmw);
    static_assert(P != MpcProtocol::kArithmeticConstant);
    switch (P) {
      case MpcProtocol::kBooleanConstant: {
        // TODO implement
        static_assert(P != MpcProtocol::kBooleanConstant, "Not implemented yet");
        // return backend_->BooleanGmwInput(party_id, input);
      }
      case MpcProtocol::kBooleanGmw: {
        return backend_->BooleanGmwInput(party_id, input);
      }
      case MpcProtocol::kBmr: {
        return backend_->BmrInput(party_id, input);
      }
      default: {
        throw(std::runtime_error(
            fmt::format("Unknown MPC protocol with id {}", static_cast<unsigned int>(P))));
      }
    }
  }
 
  template <MpcProtocol P>
  SharePointer In(BitVector<>&& input,
                  std::size_t party_id = std::numeric_limits<std::size_t>::max()) {
    static_assert(P != MpcProtocol::kArithmeticGmw);
    static_assert(P != MpcProtocol::kArithmeticConstant);
    switch (P) {
      case MpcProtocol::kBooleanConstant: {
        // TODO implement
        static_assert(P != MpcProtocol::kBooleanConstant, "Not implemented yet");
        // return backend_->BooleanGmwInput(party_id, input);
      }
      case MpcProtocol::kBooleanGmw: {
        return backend_->BooleanGmwInput(party_id, std::move(input));
      }
      case MpcProtocol::kBmr: {
        return backend_->BmrInput(party_id, input);
      }
      default: {
        throw(std::runtime_error(
            fmt::format("Unknown MPC protocol with id {}", static_cast<unsigned int>(P))));
      }
    }
  }
 
  template <MpcProtocol P, typename T = std::uint8_t,
            typename = std::enable_if_t<std::is_unsigned_v<T>>>
  SharePointer In(const std::vector<T>& input,
                  std::size_t party_id = std::numeric_limits<std::size_t>::max()) {
    switch (P) {
      case MpcProtocol::kArithmeticConstant: {
        return backend_->ConstantArithmeticGmwInput(input);
      }
      case MpcProtocol::kArithmeticGmw: {
        return backend_->ArithmeticGmwInput(party_id, input);
      }
      case MpcProtocol::kBooleanGmw: {
        throw std::runtime_error(
            "Non-binary types have to be converted to BitVectors in BooleanGMW, "
            "consider using TODO function for the input");
      }
      case MpcProtocol::kBmr: {
        throw std::runtime_error(
            "Non-binary types have to be converted to BitVectors in BMR, "
            "consider using TODO function for the input");
      }
      default: {
        throw(std::runtime_error(
            fmt::format("Unknown MPC protocol with id {}", static_cast<unsigned int>(P))));
      }
    }
  }
 
  template <MpcProtocol P, typename T = std::uint8_t,
            typename = std::enable_if_t<std::is_unsigned_v<T>>>
  SharePointer In(std::vector<T>&& input,
                  std::size_t party_id = std::numeric_limits<std::size_t>::max()) {
    switch (P) {
      case MpcProtocol::kArithmeticConstant: {
        return backend_->ConstantArithmeticGmwInput(std::move(input));
      }
      case MpcProtocol::kArithmeticGmw: {
        return backend_->ArithmeticGmwInput(party_id, std::move(input));
      }
      case MpcProtocol::kBooleanGmw: {
        throw(std::runtime_error(
            fmt::format("Non-binary types have to be converted to BitVectors in BooleanGMW, "
                        "consider using TODO function for the input")));
      }
      case MpcProtocol::kBmr: {
        throw(std::runtime_error(
            fmt::format("Non-binary types have to be converted to BitVectors in BMR, "
                        "consider using TODO function for the input")));
      }
      default: {
        throw(std::runtime_error(
            fmt::format("Unknown MPC protocol with id {}", static_cast<unsigned int>(P))));
      }
    }
  }
 
  template <MpcProtocol P, typename T = std::uint8_t,
            typename = std::enable_if_t<std::is_unsigned_v<T>>>
  SharePointer In(T input, std::size_t party_id = std::numeric_limits<std::size_t>::max()) {
    if constexpr (std::is_same_v<T, bool>) {
      if constexpr (P == MpcProtocol::kBooleanGmw)
        return backend_->BooleanGmwInput(party_id, input);
      else
        return backend_->BmrInput(party_id, input);
    } else {
      return In<P, T>(std::vector<T>{input}, party_id);
    }
  }
 
  template <MpcProtocol P, typename T = std::uint8_t,
            typename = std::enable_if_t<std::is_unsigned_v<T>>>
  SharePointer SharedIn(T input) {
    switch (P) {
      case MpcProtocol::kArithmeticConstant: {
        static_assert(P != MpcProtocol::kArithmeticConstant, "Not implemented yet");
      }
      case MpcProtocol::kArithmeticGmw: {
        encrypto::motion::RegisterPointer register_pointer{backend_->GetRegister()};
 
        encrypto::motion::WirePointer wire =
            std::make_shared<encrypto::motion::proto::arithmetic_gmw::Wire<T>>(input, *backend_);
        register_pointer->RegisterNextWire(wire);
        wire->SetOnlineFinished();
 
        return std::make_shared<encrypto::motion::proto::arithmetic_gmw::Share<T>>(wire);
      }
      case MpcProtocol::kBooleanGmw: {
        throw std::runtime_error(
            "Non-binary types have to be converted to BitVectors in BooleanGMW, "
            "consider using TODO function for the input");
      }
      case MpcProtocol::kBmr: {
        throw std::runtime_error(
            "Non-binary types have to be converted to BitVectors in BMR, "
            "consider using TODO function for the input");
      }
      default: {
        throw(std::runtime_error(
            fmt::format("Unknown MPC protocol with id {}", static_cast<unsigned int>(P))));
      }
    }
  }
 
  template <MpcProtocol P, typename T = std::uint8_t,
      typename = std::enable_if_t<std::is_unsigned_v<T>>>
  SharePointer SharedIn(const std::vector<T>& input) {
    switch (P) {
      case MpcProtocol::kArithmeticConstant: {
        static_assert(P != MpcProtocol::kArithmeticConstant, "Not implemented yet");
      }
      case MpcProtocol::kArithmeticGmw: {
        encrypto::motion::RegisterPointer register_pointer{backend_->GetRegister()};
 
        encrypto::motion::WirePointer wire =
            std::make_shared<encrypto::motion::proto::arithmetic_gmw::Wire<T>>(input, *backend_);
        register_pointer->RegisterNextWire(wire);
        wire->SetOnlineFinished();
 
        return std::make_shared<encrypto::motion::proto::arithmetic_gmw::Share<T>>(wire);
      }
      case MpcProtocol::kBooleanGmw: {
        throw std::runtime_error(
            "Non-binary types have to be converted to BitVectors in BooleanGMW, "
            "consider using TODO function for the input");
      }
      case MpcProtocol::kBmr: {
        throw std::runtime_error(
            "Non-binary types have to be converted to BitVectors in BMR, "
            "consider using TODO function for the input");
      }
      default: {
        throw(std::runtime_error(
            fmt::format("Unknown MPC protocol with id {}", static_cast<unsigned int>(P))));
      }
    }
  }
 
  template <MpcProtocol P>
  SharePointer SharedIn(std::span<const BitVector<>> input) {
    static_assert(P != MpcProtocol::kArithmeticGmw);
    static_assert(P != MpcProtocol::kArithmeticConstant);
 
    switch (P) {
      case MpcProtocol::kBooleanConstant: {
        static_assert(P != MpcProtocol::kBooleanConstant, "Not implemented yet");
      }
      case MpcProtocol::kBooleanGmw: {
        std::vector<encrypto::motion::WirePointer> wires(input.size());
        encrypto::motion::RegisterPointer register_pointer{backend_->GetRegister()};
 
        for (std::size_t i = 0; i < wires.size(); i++) {
          wires[i] =
              std::make_shared<encrypto::motion::proto::boolean_gmw::Wire>(input[i], *backend_);
          register_pointer->RegisterNextWire(wires[i]);
          wires[i]->SetOnlineFinished();
        }
 
        return std::make_shared<encrypto::motion::proto::boolean_gmw::Share>(wires);
      }
      case MpcProtocol::kBmr: {
        static_assert(P != MpcProtocol::kBmr, "Not implemented yet");
      }
      default: {
        throw(std::runtime_error(
            fmt::format("Unknown MPC protocol with id {}", static_cast<unsigned int>(P))));
      }
    }
  }
 
  SharePointer Xor(const SharePointer& a, const SharePointer& b);
 
  SharePointer Out(SharePointer parent, std::size_t output_owner);
 
  SharePointer Add(const SharePointer& a, const SharePointer& b);
 
  SharePointer And(const SharePointer& a, const SharePointer& b);
 
  void Run(std::size_t repetitions = 1);
 
  void Reset();
 
  void Clear();
 
  const auto& GetLogger() { return logger_; }
 
  void Finish();
 
  auto& GetBackend() { return backend_; }
 
 private:
  std::unique_ptr<communication::CommunicationLayer> communication_layer_;
  ConfigurationPointer configuration_;
  std::shared_ptr<Logger> logger_;
  BackendPointer backend_;
  std::atomic<bool> finished_ = false;
  std::atomic<bool> connected_ = false;
 
  void EvaluateCircuit();
};
 
std::vector<std::unique_ptr<Party>> MakeLocallyConnectedParties(const std::size_t number_of_parties,
                                                                std::uint16_t port,
                                                                const bool logging = false);
 
using PartyPointer = std::unique_ptr<Party>;
 
}  // namespace encrypto::motion