init rc2 network

.gitignore

@@ -116,3 +116,10 @@ Thumbs.db
 
 # Sphinx build
 _build/
+
+# environment
+.env
+
+# temp doc files
+doc/readme.md
+doc/xml

.gitmodules

@@ -1,12 +1,18 @@
 [submodule "SimpleOT"]
-	path = SimpleOT
+	path = deps/SimpleOT
 	url = https://github.com/mkskeller/SimpleOT
 [submodule "mpir"]
-	path = mpir
-	url = git://github.com/wbhart/mpir.git
+	path = deps/mpir
+	url = https://github.com/wbhart/mpir
 [submodule "Programs/Circuits"]
 	path = Programs/Circuits
 	url = https://github.com/mkskeller/bristol-fashion
 [submodule "simde"]
-	path = simde
+	path = deps/simde
 	url = https://github.com/simd-everywhere/simde
+[submodule "deps/libOTe"]
+	path = deps/libOTe
+	url = https://github.com/mkskeller/softspoken-implementation
+[submodule "deps/SimplestOT_C"]
+	path = deps/SimplestOT_C
+	url = https://github.com/mkskeller/SimplestOT_C

BMR/Party.cpp

@@ -249,6 +249,7 @@ FakeProgramParty::FakeProgramParty(int argc, const char** argv) :
 	}
 	cout << "Compiler: " << prev << endl;
 	P = new PlainPlayer(N, 0);
+	Share<gf2n_long>::MAC_Check::setup(*P);
 	if (argc > 4)
 		threshold = atoi(argv[4]);
 	cout << "Threshold for multi-threaded evaluation: " << threshold << endl;
@@ -259,7 +260,6 @@ ProgramParty::~ProgramParty()
 	reset();
 	if (P)
 	{
-		cerr << "Data sent: " << 1e-6 * P->comm_stats.total_data() << " MB" << endl;
 		delete P;
 	}
 	delete[] eval_threads;
@@ -281,6 +281,7 @@ FakeProgramParty::~FakeProgramParty()
         cerr << "Dynamic storage: " << 1e-9 * dynamic_memory.capacity_in_bytes()
                 << " GB" << endl;
 #endif
+    Share<gf2n_long>::MAC_Check::teardown();
 }
 
 void FakeProgramParty::_compute_prfs_outputs(Key* keys)

BMR/RealGarbleWire.h

@@ -48,8 +48,6 @@ class RealGarbleWire : public PRFRegister
 	static void inputbvec(GC::Processor<GC::Secret<RealGarbleWire>>& processor,
 			ProcessorBase& input_processor, const vector<int>& args);
 
-	RealGarbleWire(const Register& reg) : PRFRegister(reg) {}
-
 	void garble(PRFOutputs& prf_output, const RealGarbleWire<T>& left,
 			const RealGarbleWire<T>& right);
 

BMR/RealGarbleWire.hpp

@@ -110,7 +110,7 @@ void RealGarbleWire<T>::inputbvec(
 {
 	GarbleInputter<T> inputter;
 	processor.inputbvec(inputter, input_processor, args,
-			inputter.party.P->my_num());
+			*inputter.party.P);
 }
 
 template<class T>
@@ -175,7 +175,7 @@ void GarbleInputter<T>::exchange()
 		assert(party.P != 0);
 		assert(party.MC != 0);
 		auto& protocol = party.shared_proc->protocol;
-		protocol.init_mul(party.shared_proc);
+		protocol.init_mul();
 		for (auto& tuple : tuples)
 			protocol.prepare_mul(tuple.first->mask,
 					T::constant(1, party.P->my_num(), party.mac_key)

BMR/RealProgramParty.hpp

@@ -28,7 +28,7 @@ RealProgramParty<T>* RealProgramParty<T>::singleton = 0;
 
 template<class T>
 RealProgramParty<T>::RealProgramParty(int argc, const char** argv) :
-		garble_processor(garble_machine), dummy_proc({{}, 0})
+		garble_processor(garble_machine), dummy_proc({}, 0)
 {
 	assert(singleton == 0);
 	singleton = this;
@@ -64,7 +64,6 @@ RealProgramParty<T>::RealProgramParty(int argc, const char** argv) :
 	    online_opts = {opt, argc, argv, 1000};
 	else
 	    online_opts = {opt, argc, argv};
-	assert(not online_opts.interactive);
 
 	online_opts.finalize(opt, argc, argv);
 	this->load(online_opts.progname);
@@ -97,8 +96,6 @@ RealProgramParty<T>::RealProgramParty(int argc, const char** argv) :
 	if (online_opts.live_prep)
 	{
 		mac_key.randomize(prng);
-		if (T::needs_ot)
-			BaseMachine::s().ot_setups.push_back({*P, true});
 		prep = new typename T::LivePrep(0, usage);
 	}
 	else
@@ -107,13 +104,13 @@ RealProgramParty<T>::RealProgramParty(int argc, const char** argv) :
 		prep = new Sub_Data_Files<T>(N, prep_dir, usage);
 	}
 
+	T::MAC_Check::setup(*P);
 	MC = new typename T::MAC_Check(mac_key);
 
 	garble_processor.reset(program);
-	this->processor.open_input_file(N.my_num(), 0);
+	this->processor.open_input_file(N.my_num(), 0, online_opts.cmd_private_input_file);
+	this->processor.setup_redirection(P->my_num(), 0, online_opts, this->processor.out);
 
-	T::bit_type::mac_key_type::init_field();
-	GC::ShareThread<typename T::bit_type> share_thread(N, online_opts, *P, 0, usage);
 	shared_proc = new SubProcessor<T>(dummy_proc, *MC, *prep, *P);
 
 	auto& inputter = shared_proc->input;
@@ -157,7 +154,10 @@ RealProgramParty<T>::RealProgramParty(int argc, const char** argv) :
 	while (next != GC::DONE_BREAK);
 
 	MC->Check(*P);
-	data_sent = P->comm_stats.total_data() + prep->data_sent();
+	data_sent = P->total_comm().sent;
+
+	if (online_opts.verbose)
+	    P->total_comm().print();
 
 	this->machine.write_memory(this->N.my_num());
 }
@@ -175,15 +175,17 @@ void RealProgramParty<T>::garble()
 		garble_jobs.clear();
 		garble_inputter->reset_all(*P);
 		auto& protocol = *garble_protocol;
-		protocol.init_mul(shared_proc);
+		protocol.init(*prep, shared_proc->MC);
+		protocol.init_mul();
 
 		next = this->first_phase(program, garble_processor, this->garble_machine);
 
 		garble_inputter->exchange();
 		protocol.exchange();
 
 		typename T::Protocol second_protocol(*P);
-		second_protocol.init_mul(shared_proc);
+		second_protocol.init(*prep, shared_proc->MC);
+		second_protocol.init_mul();
 		for (auto& job : garble_jobs)
 			job.middle_round(*this, second_protocol);
 
@@ -215,6 +217,7 @@ RealProgramParty<T>::~RealProgramParty()
 	delete garble_inputter;
 	delete garble_protocol;
 	cout << "Data sent = " << data_sent * 1e-6 << " MB" << endl;
+	T::MAC_Check::teardown();
 }
 
 template<class T>

BMR/Register.cpp

@@ -568,6 +568,7 @@ void EvalRegister::inputb(GC::Processor<GC::Secret<EvalRegister> >& processor,
 	octetStream& my_os = oss[party.get_id() - 1];
 	vector<InputAccess> accesses;
 	InputArgList a(args);
+	processor.complexity += a.n_input_bits();
 	for (auto x : a)
 	{
 		accesses.push_back({x , processor});

BMR/Register.h

@@ -23,6 +23,7 @@ using namespace std;
 #include "Tools/PointerVector.h"
 #include "Tools/Bundle.h"
 #include "Tools/SwitchableOutput.h"
+#include "Processor/Instruction.h"
 
 //#define PAD_TO_8(n) (n+8-n%8)
 #define PAD_TO_8(n) (n)
@@ -151,7 +152,7 @@ class Register {
 	                   *  for pipelining matters.
 	                   */
 
-	Register(int n_parties);
+	Register();
 
 	void init(int n_parties);
 	void init(int rfd, int n_parties);
@@ -234,6 +235,9 @@ class Phase
 	template <class T>
 	static void ands(T& processor, const vector<int>& args) { processor.ands(args); }
 	template <class T>
+	static void andrsvec(T& processor, const vector<int>& args)
+	{ processor.andrsvec(args); }
+	template <class T>
 	static void xors(T& processor, const vector<int>& args) { processor.xors(args); }
 	template <class T>
 	static void inputb(T& processor, const vector<int>& args) { processor.input(args); }
@@ -243,6 +247,9 @@ class Phase
 	template <class T>
 	static T get_input(int from, GC::Processor<T>& processor, int n_bits)
 	{ return T::input(from, processor.get_input(n_bits), n_bits); }
+	template<class U>
+	static void reveal_inst(GC::Processor<U>& processor, const vector<int>& args)
+	{ processor.reveal(args); }
 
 	template<class T>
 	static void convcbit(Integer& dest, const GC::Clear& source, T&)
@@ -274,10 +281,6 @@ class ProgramRegister : public Phase, public Register
 
 	static int threshold(int) { throw not_implemented(); }
 
-	static Register new_reg();
-	static Register tmp_reg() { return new_reg(); }
-	static Register and_reg() { return new_reg(); }
-
 	template<class T>
 	static void store(NoMemory& dest,
 			const vector<GC::WriteAccess<T> >& accesses) { (void)dest; (void)accesses; }
@@ -286,6 +289,15 @@ class ProgramRegister : public Phase, public Register
 	static void inputbvec(T& processor, ProcessorBase& input_processor,
 			const vector<int>& args);
 
+    template<class U>
+    static void convcbit2s(GC::Processor<U>&, const BaseInstruction&)
+    { throw runtime_error("convcbit2s not implemented"); }
+    template<class U>
+    static void andm(GC::Processor<U>&, const BaseInstruction&)
+    { throw runtime_error("andm not implemented"); }
+
+    static void run_tapes(const vector<int>&) { throw not_implemented(); }
+
 	// most BMR phases don't need actual input
 	template<class T>
 	static T get_input(GC::Processor<T>& processor, const InputArgs& args)
@@ -295,8 +307,6 @@ class ProgramRegister : public Phase, public Register
 	void other_input(Input&, int) {}
 
 	char get_output() { return 0; }
-
-	ProgramRegister(const Register& reg) : Register(reg) {}
 };
 
 class PRFRegister : public ProgramRegister
@@ -308,8 +318,6 @@ class PRFRegister : public ProgramRegister
 	static void load(vector<GC::ReadAccess<T> >& accesses,
 			const NoMemory& source);
 
-	PRFRegister(const Register& reg) : ProgramRegister(reg) {}
-
 	void op(const PRFRegister& left, const PRFRegister& right, Function func);
 	void XOR(const Register& left, const Register& right);
 	void input(party_id_t from, char input = -1);
@@ -385,8 +393,6 @@ class EvalRegister : public ProgramRegister
 	static void convcbit(Integer& dest, const GC::Clear& source,
 	        GC::Processor<GC::Secret<EvalRegister>>& proc);
 
-	EvalRegister(const Register& reg) : ProgramRegister(reg) {}
-
 	void op(const ProgramRegister& left, const ProgramRegister& right, Function func);
 	void XOR(const Register& left, const Register& right);
 
@@ -416,8 +422,6 @@ class GarbleRegister : public ProgramRegister
 	static void load(vector<GC::ReadAccess<T> >& accesses,
 			const NoMemory& source);
 
-	GarbleRegister(const Register& reg) : ProgramRegister(reg) {}
-
 	void op(const Register& left, const Register& right, Function func);
 	void XOR(const Register& left, const Register& right);
         void input(party_id_t from, char value = -1);
@@ -441,8 +445,6 @@ class RandomRegister : public ProgramRegister
 	static void load(vector<GC::ReadAccess<T> >& accesses,
 			const NoMemory& source);
 
-	RandomRegister(const Register& reg) : ProgramRegister(reg) {}
-
 	void randomize();
 
 	void op(const Register& left, const Register& right, Function func);
@@ -458,12 +460,6 @@ class RandomRegister : public ProgramRegister
 };
 
 
-inline Register::Register(int n_parties) :
-		garbled_entry(n_parties), external(NO_SIGNAL),
-		mask(NO_SIGNAL), keys(n_parties)
-{
-}
-
 inline void KeyVector::operator=(const KeyVector& other)
 {
 	resize(other.size());

BMR/Register.hpp

@@ -14,15 +14,7 @@ void ProgramRegister::inputbvec(T& processor, ProcessorBase& input_processor,
 		const vector<int>& args)
 {
 	NoOpInputter inputter;
-	int my_num = -1;
-	try
-	{
-		my_num = ProgramParty::s().P->my_num();
-	}
-	catch (exception&)
-	{
-	}
-	processor.inputbvec(inputter, input_processor, args, my_num);
+	processor.inputbvec(inputter, input_processor, args, *ProgramParty::s().P);
 }
 
 template<class T>
@@ -31,7 +23,7 @@ void EvalRegister::inputbvec(T& processor, ProcessorBase& input_processor,
 {
 	EvalInputter inputter;
 	processor.inputbvec(inputter, input_processor, args,
-			ProgramParty::s().P->my_num());
+			*ProgramParty::s().P);
 }
 
 template <class T>

BMR/Register_inline.h

@@ -9,10 +9,10 @@
 #include "CommonParty.h"
 #include "Party.h"
 
-
-inline Register ProgramRegister::new_reg()
+inline Register::Register() :
+        garbled_entry(CommonParty::s().get_n_parties()), external(NO_SIGNAL),
+        mask(NO_SIGNAL), keys(CommonParty::s().get_n_parties())
 {
-	return Register(CommonParty::s().get_n_parties());
 }
 
 #endif /* BMR_REGISTER_INLINE_H_ */

BMR/TrustedParty.cpp

@@ -42,6 +42,12 @@ BaseTrustedParty::BaseTrustedParty()
 	_received_gc_received = 0;
 	n_received = 0;
 	randomfd = open("/dev/urandom", O_RDONLY);
+	done_filling = false;
+}
+
+BaseTrustedParty::~BaseTrustedParty()
+{
+    close(randomfd);
 }
 
 TrustedProgramParty::TrustedProgramParty(int argc, char** argv) :

BMR/TrustedParty.h

@@ -20,7 +20,7 @@ class BaseTrustedParty : virtual public CommonFakeParty {
 	vector<SendBuffer> msg_input_masks;
 
 	BaseTrustedParty();
-	virtual ~BaseTrustedParty() {}
+	virtual ~BaseTrustedParty();
 
 	/* From NodeUpdatable class */
 	virtual void NodeReady();
@@ -104,7 +104,6 @@ class TrustedProgramParty : public BaseTrustedParty {
 	void add_all_keys(const Register& reg, bool external);
 };
 
-
 inline void BaseTrustedParty::add_keys(const Register& reg)
 {
 	for(int p = 0; p < get_n_parties(); p++)