├── .gitignore
├── .gitmodules
├── Auth
    ├── MAC_Check.cpp
    ├── MAC_Check.h
    ├── Subroutines.cpp
    ├── Subroutines.h
    ├── Summer.cpp
    ├── Summer.h
    ├── fake-stuff.cpp
    └── fake-stuff.h
├── CHANGELOG.md
├── CONFIG
├── Check-Offline.cpp
├── Compiler
    ├── __init__.py
    ├── allocator.py
    ├── comparison.py
    ├── compilerLib.py
    ├── config.py
    ├── dijkstra.py
    ├── exceptions.py
    ├── floatingpoint.py
    ├── graph.py
    ├── gs.py
    ├── instructions.py
    ├── instructions_base.py
    ├── library.py
    ├── oram.py
    ├── path_oram.py
    ├── permutation.py
    ├── program.py
    ├── tools.py
    ├── types.py
    └── util.py
├── Exceptions
    └── Exceptions.h
├── ExternalIO
    ├── README.md
    ├── bankers-bonus-client.cpp
    └── bankers-bonus-commsec-client.cpp
├── FHE
    ├── AddableVector.h
    ├── Ciphertext.cpp
    ├── Ciphertext.h
    ├── DiscreteGauss.cpp
    ├── DiscreteGauss.h
    ├── FFT.cpp
    ├── FFT.h
    ├── FFT_Data.cpp
    ├── FFT_Data.h
    ├── FHE_Keys.cpp
    ├── FHE_Keys.h
    ├── FHE_Params.cpp
    ├── FHE_Params.h
    ├── Generator.h
    ├── Matrix.cpp
    ├── Matrix.h
    ├── NTL-Subs.cpp
    ├── NTL-Subs.h
    ├── NoiseBounds.cpp
    ├── NoiseBounds.h
    ├── P2Data.cpp
    ├── P2Data.h
    ├── PPData.cpp
    ├── PPData.h
    ├── Plaintext.cpp
    ├── Plaintext.h
    ├── QGroup.cpp
    ├── QGroup.h
    ├── Random_Coins.cpp
    ├── Random_Coins.h
    ├── Ring.cpp
    ├── Ring.h
    ├── Ring_Element.cpp
    ├── Ring_Element.h
    ├── Rq_Element.cpp
    ├── Rq_Element.h
    └── tools.h
├── FHEOffline
    ├── CutAndChooseMachine.cpp
    ├── CutAndChooseMachine.h
    ├── DataSetup.cpp
    ├── DataSetup.h
    ├── DistDecrypt.cpp
    ├── DistDecrypt.h
    ├── DistKeyGen.cpp
    ├── DistKeyGen.h
    ├── EncCommit.cpp
    ├── EncCommit.h
    ├── FHE-Subroutines.cpp
    ├── FullSetup.cpp
    ├── FullSetup.h
    ├── Multiplier.cpp
    ├── Multiplier.h
    ├── PairwiseGenerator.cpp
    ├── PairwiseGenerator.h
    ├── PairwiseMachine.cpp
    ├── PairwiseMachine.h
    ├── PairwiseSetup.cpp
    ├── PairwiseSetup.h
    ├── Player-Offline.h
    ├── Producer.cpp
    ├── Producer.h
    ├── Proof.cpp
    ├── Proof.h
    ├── Prover.cpp
    ├── Prover.h
    ├── Reshare.cpp
    ├── Reshare.h
    ├── Sacrificing.cpp
    ├── Sacrificing.h
    ├── SimpleDistDecrypt.cpp
    ├── SimpleDistDecrypt.h
    ├── SimpleEncCommit.cpp
    ├── SimpleEncCommit.h
    ├── SimpleGenerator.cpp
    ├── SimpleGenerator.h
    ├── SimpleMachine.cpp
    ├── SimpleMachine.h
    ├── Verifier.cpp
    ├── Verifier.h
    └── config.h
├── Fake-Offline.cpp
├── HOSTS.example
├── License.txt
├── Makefile
├── Math
    ├── Integer.cpp
    ├── Integer.h
    ├── Setup.cpp
    ├── Setup.h
    ├── Share.cpp
    ├── Share.h
    ├── Subroutines.cpp
    ├── Subroutines.h
    ├── Zp_Data.cpp
    ├── Zp_Data.h
    ├── bigint.cpp
    ├── bigint.h
    ├── field_types.h
    ├── gf2n.cpp
    ├── gf2n.h
    ├── gf2nlong.cpp
    ├── gf2nlong.h
    ├── gfp.cpp
    ├── gfp.h
    ├── modp.cpp
    ├── modp.h
    └── operators.h
├── Networking
    ├── Player.cpp
    ├── Player.h
    ├── Receiver.cpp
    ├── Receiver.h
    ├── STS.cpp
    ├── STS.h
    ├── Sender.cpp
    ├── Sender.h
    ├── Server.cpp
    ├── Server.h
    ├── ServerSocket.cpp
    ├── ServerSocket.h
    ├── data.h
    ├── sockets.cpp
    └── sockets.h
├── OT
    ├── BaseOT.cpp
    ├── BaseOT.h
    ├── BitMatrix.cpp
    ├── BitMatrix.h
    ├── BitVector.cpp
    ├── BitVector.h
    ├── NPartyTripleGenerator.cpp
    ├── NPartyTripleGenerator.h
    ├── OTExtension.cpp
    ├── OTExtension.h
    ├── OTExtensionWithMatrix.cpp
    ├── OTExtensionWithMatrix.h
    ├── OTMachine.cpp
    ├── OTMachine.h
    ├── OTMultiplier.cpp
    ├── OTMultiplier.h
    ├── OTTripleSetup.cpp
    ├── OTTripleSetup.h
    ├── OText_main.cpp
    ├── OutputCheck.h
    ├── Tools.cpp
    ├── Tools.h
    ├── TripleMachine.cpp
    └── TripleMachine.h
├── Player-Online.cpp
├── Processor
    ├── Binary_File_IO.cpp
    ├── Binary_File_IO.h
    ├── Buffer.cpp
    ├── Buffer.h
    ├── Data_Files.cpp
    ├── Data_Files.h
    ├── ExternalClients.cpp
    ├── ExternalClients.h
    ├── Input.cpp
    ├── Input.h
    ├── InputTuple.h
    ├── Instruction.cpp
    ├── Instruction.h
    ├── Machine.cpp
    ├── Machine.h
    ├── Memory.cpp
    ├── Memory.h
    ├── Online-Thread.cpp
    ├── Online-Thread.h
    ├── PrivateOutput.cpp
    ├── PrivateOutput.h
    ├── Processor.cpp
    ├── Processor.h
    ├── Program.cpp
    └── Program.h
├── Programs
    └── Source
    │   ├── aes.mpc
    │   ├── bankers_bonus.mpc
    │   ├── bankers_bonus_commsec.mpc
    │   ├── dijkstra_tutorial.mpc
    │   ├── fixed_point_tutorial.mpc
    │   ├── gale-shapley_tutorial.mpc
    │   ├── htmac.mpc
    │   ├── oram_tutorial.mpc
    │   ├── prf_leg.mpc
    │   ├── prf_mimc.mpc
    │   ├── tpmpc_tutorial.mpc
    │   ├── tutorial.mpc
    │   └── vickrey.mpc
├── README.md
├── Scripts
    ├── gen_input_f2n.cpp
    ├── gen_input_fp.cpp
    ├── run-common.sh
    ├── run-online.sh
    └── setup-online.sh
├── Server.cpp
├── Tools
    ├── Commit.cpp
    ├── Commit.h
    ├── Config.cpp
    ├── Config.h
    ├── Lock.cpp
    ├── Lock.h
    ├── MMO.cpp
    ├── MMO.h
    ├── MemoryUsage.h
    ├── OfflineMachineBase.cpp
    ├── OfflineMachineBase.h
    ├── Signal.cpp
    ├── Signal.h
    ├── WaitQueue.h
    ├── aes-ni.cpp
    ├── aes.cpp
    ├── aes.h
    ├── avx_memcpy.h
    ├── benchmarking.h
    ├── ezOptionParser-MIT-LICENSE
    ├── ezOptionParser.h
    ├── int.h
    ├── mkpath.cpp
    ├── mkpath.h
    ├── names.cpp
    ├── octetStream.cpp
    ├── octetStream.h
    ├── parse.h
    ├── pprint.h
    ├── random.cpp
    ├── random.h
    ├── sha1.cpp
    ├── sha1.h
    ├── time-func.cpp
    └── time-func.h
├── check-passive.cpp
├── client-setup.cpp
├── cnc-offline.cpp
├── compile.py
├── ot-offline.cpp
├── pairwise-offline.cpp
├── simple-offline.cpp
├── spdz2-offline.cpp
└── tutorial.md


/.gitignore:
--------------------------------------------------------------------------------
  1 | # Offline data, runtime logs #
  2 | ##############################
  3 | Player-Data
  4 | Player-Data/*
  5 | Prep-Data/*
  6 | logs/*
  7 | Language-Definition/main.pdf
  8 | keys/*
  9 | 
 10 | # Personal CONFIG file #
 11 | ##############################
 12 | CONFIG.mine
 13 | config_mine.py
 14 | 
 15 | # Temporary files #
 16 | ###################
 17 | *.bak
 18 | *.orig
 19 | *.rej
 20 | *.tmp
 21 | callgrind.out.*
 22 | 
 23 | # Vim
 24 | .*.swp
 25 | tags
 26 | 
 27 | # Eclipse #
 28 | ###########
 29 | .project
 30 | .cproject
 31 | .settings
 32 | 
 33 | # VS Code IDE #
 34 | ###############
 35 | .vscode/**
 36 | 
 37 | # Temporary files #
 38 | ###################
 39 | *.bak
 40 | *.orig
 41 | *.rej
 42 | *.tmp
 43 | callgrind.out.*
 44 | 
 45 | # Compiled source #
 46 | ###################
 47 | Programs/Bytecode/*
 48 | Programs/Schedules/*
 49 | Programs/Public-Input/*
 50 | *.com
 51 | *.class
 52 | *.dll
 53 | *.exe
 54 | *.x
 55 | *.o
 56 | *.so
 57 | *.pyc
 58 | *.bc
 59 | *.sch
 60 | *.a
 61 | *.static
 62 | *.d
 63 | 
 64 | # Packages #
 65 | ############
 66 | # it's better to unpack these files and commit the raw source
 67 | # git has its own built in compression methods
 68 | *.7z
 69 | *.dmg
 70 | *.gz
 71 | *.iso
 72 | *.jar
 73 | *.rar
 74 | *.tar
 75 | *.zip
 76 | 
 77 | # Latex #
 78 | #########
 79 | *.aux
 80 | *.lof
 81 | *.log
 82 | *.lot
 83 | *.fls
 84 | *.out
 85 | *.toc
 86 | *.fmt
 87 | *.bbl
 88 | *.bcf
 89 | *.blg
 90 | 
 91 | 
 92 | # Logs and databases #
 93 | ######################
 94 | *.log
 95 | *.sql
 96 | *.sqlite
 97 | *.data
 98 | Persistence/*
 99 | 
100 | # OS generated files #
101 | ######################
102 | *~
103 | .DS_Store
104 | .DS_Store?
105 | ._*
106 | .Spotlight-V100
107 | .Trashes
108 | ehthumbs.db
109 | Thumbs.db
110 | **/*.x.dSYM/**
111 | 


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "SimpleOT"]
2 | 	path = SimpleOT
3 | 	url = git@github.com:pascholl/SimpleOT.git
4 | 


--------------------------------------------------------------------------------
/Auth/Summer.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * Summer.cpp
 5 |  *
 6 |  */
 7 | 
 8 | #include "Auth/Summer.h"
 9 | #include "Auth/MAC_Check.h"
10 | #include "Tools/int.h"
11 | 
12 | template<class T>
13 | Summer<T>::Summer(int sum_players, int last_sum_players, int next_sum_players,
14 |         Player* send_player, Player* receive_player, Parallel_MAC_Check<T>& MC) :
15 |         sum_players(sum_players), last_sum_players(last_sum_players), next_sum_players(next_sum_players),
16 |         base_player(0), MC(MC),send_player(send_player), receive_player(receive_player),
17 |         thread(0), stop(false), size(0)
18 | {
19 |     cout << "Setting up summation by " << sum_players << " players" << endl;
20 | }
21 | 
22 | template<class T>
23 | Summer<T>::~Summer()
24 | {
25 |     delete send_player;
26 |     if (timer.elapsed())
27 |     cout << T::type_string() << " summation by " << sum_players << " players: "
28 |         << timer.elapsed() << endl;
29 | }
30 | 
31 | template<class T>
32 | void Summer<T>::run()
33 | {
34 |     octetStream os;
35 | 
36 |     while (true)
37 |     {
38 |         int size = 0;
39 |         if (!input_queue.pop(size))
40 |             break;
41 | 
42 |         int my_relative_num = positive_modulo(send_player->my_num() - base_player, send_player->num_players());
43 |         if (my_relative_num < sum_players)
44 |         {
45 |             // first summer takes inputs from queue
46 |             if (last_sum_players == send_player->num_players())
47 |                 share_queue.pop(values);
48 |             else
49 |             {
50 |                 values.resize(size);
51 |                 receive_player->receive_player(receive_player->my_num(),os,true);
52 |                 for (int i = 0; i < size; i++)
53 |                     values[i].unpack(os);
54 |             }
55 | 
56 |             timer.start();
57 |             if (T::t() == 2)
58 |                 add_openings<T,2>(values, *receive_player, sum_players,
59 |                         last_sum_players, base_player, MC);
60 |             else
61 |                 add_openings<T,0>(values, *receive_player, sum_players,
62 |                         last_sum_players, base_player, MC);
63 |             timer.stop();
64 | 
65 |             os.reset_write_head();
66 |             for (int i = 0; i < size; i++)
67 |                 values[i].pack(os);
68 | 
69 |             if (sum_players > 1)
70 |             {
71 |                 int receiver = positive_modulo(base_player + my_relative_num % next_sum_players,
72 |                         send_player->num_players());
73 |                 send_player->send_to(receiver, os, true);
74 |             }
75 |             else
76 |             {
77 |                 send_player->send_all(os);
78 |                 MC.value_queue.push(values);
79 |             }
80 |         }
81 | 
82 |         if (sum_players == 1)
83 |             output_queue.push(size);
84 | 
85 |         base_player = (base_player + 1) % send_player->num_players();
86 |     }
87 | }
88 | 
89 | template class Summer<gfp>;
90 | template class Summer<gf2n>;
91 | 
92 | #ifdef USE_GF2N_LONG
93 | template class Summer<gf2n_short>;
94 | #endif
95 | 


--------------------------------------------------------------------------------
/Auth/Summer.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * Summer.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef OFFLINE_SUMMER_H_
 9 | #define OFFLINE_SUMMER_H_
10 | 
11 | #include "Networking/Player.h"
12 | #include "Tools/WaitQueue.h"
13 | #include "Tools/time-func.h"
14 | 
15 | #include <pthread.h>
16 | #include <vector>
17 | using namespace std;
18 | 
19 | template<class T>
20 | class Parallel_MAC_Check;
21 | 
22 | template<class T>
23 | class Summer
24 | {
25 |     int sum_players, last_sum_players, next_sum_players;
26 |     int base_player;
27 |     Parallel_MAC_Check<T>& MC;
28 |     Player* send_player;
29 |     Player* receive_player;
30 |     Timer timer;
31 | 
32 | public:
33 |     vector<T> values;
34 | 
35 |     pthread_t thread;
36 |     WaitQueue<int> input_queue, output_queue;
37 |     bool stop;
38 |     int size;
39 |     WaitQueue< vector<T> > share_queue;
40 | 
41 |     Summer(int sum_players, int last_sum_players, int next_sum_players,
42 |             Player* send_player, Player* receive_player, Parallel_MAC_Check<T>& MC);
43 |     ~Summer();
44 |     void run();
45 | };
46 | 
47 | #endif /* OFFLINE_SUMMER_H_ */
48 | 


--------------------------------------------------------------------------------
/Auth/fake-stuff.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | 
 4 | #ifndef _fake_stuff
 5 | #define _fake_stuff
 6 | 
 7 | #include "Math/gf2n.h"
 8 | #include "Math/gfp.h"
 9 | #include "Math/Share.h"
10 | 
11 | #include <fstream>
12 | using namespace std;
13 | 
14 | template<class T>
15 | void make_share(vector<Share<T> >& Sa,const T& a,int N,const T& key,PRNG& G);
16 | 
17 | template<class T>
18 | void check_share(vector<Share<T> >& Sa,T& value,T& mac,int N,const T& key);
19 | 
20 | void expand_byte(gf2n_short& a,int b);
21 | void collapse_byte(int& b,const gf2n_short& a);
22 | 
23 | // Generate MAC key shares
24 | void generate_keys(const string& directory, int nplayers);
25 | 
26 | template <class T>
27 | void write_mac_keys(const string& directory, int player_num, int nplayers, gfp keyp, T key2);
28 | 
29 | // Read MAC key shares and compute keys
30 | void read_keys(const string& directory, gfp& keyp, gf2n& key2, int nplayers);
31 | 
32 | template <class T>
33 | class Files
34 | {
35 | public:
36 |   ofstream* outf;
37 |   int N;
38 |   T key;
39 |   PRNG G;
40 |   Files(int N, const T& key, const string& prefix) : N(N), key(key)
41 |   {
42 |     outf = new ofstream[N];
43 |     for (int i=0; i<N; i++)
44 |       {
45 |         stringstream filename;
46 |         filename << prefix << "-P" << i;
47 |         cout << "Opening " << filename.str() << endl;
48 |         outf[i].open(filename.str().c_str(),ios::out | ios::binary);
49 |         if (outf[i].fail())
50 |           throw file_error(filename.str().c_str());
51 |       }
52 |     G.ReSeed();
53 |   }
54 |   ~Files()
55 |   {
56 |     delete[] outf;
57 |   }
58 |   void output_shares(const T& a)
59 |   {
60 |     vector<Share<T> > Sa(N);
61 |     make_share(Sa,a,N,key,G);
62 |     for (int j=0; j<N; j++)
63 |       Sa[j].output(outf[j],false);
64 |   }
65 | };
66 | 
67 | #endif
68 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | The changelog explains changes pulled through from the private development repository. Bug fixes and small enchancements are committed between releases and not documented here.
 2 | 
 3 | ## 0.0.3 (Mar 2, 2018)
 4 | 
 5 | - Added offline phases based on homomorphic encryption, used in the [SPDZ-2 paper](https://eprint.iacr.org/2012/642) and the [Overdrive paper](https://eprint.iacr.org/2017/1230).
 6 | - On macOS, the minimum requirement is now Sierra.
 7 | - Compilation with LLVM/clang is now possible (tested with 3.8).
 8 | 
 9 | ## 0.0.2 (Sep 13, 2017)
10 | 
11 | ### Support sockets based external client input and output to a SPDZ MPC program.
12 | 
13 | See the [ExternalIO directory](./ExternalIO/README.md) for more details and examples.
14 | 
15 | Note that [libsodium](https://download.libsodium.org/doc/) is now a dependency on the SPDZ build. 
16 | 
17 | Added compiler instructions:
18 | 
19 | * LISTEN
20 | * ACCEPTCLIENTCONNECTION
21 | * CONNECTIPV4
22 | * WRITESOCKETSHARE
23 | * WRITESOCKETINT
24 | 
25 | Removed instructions:
26 | 
27 | * OPENSOCKET
28 | * CLOSESOCKET
29 |  
30 | Modified instructions:
31 | 
32 | * READSOCKETC
33 | * READSOCKETS
34 | * READSOCKETINT
35 | * WRITESOCKETC
36 | * WRITESOCKETS
37 | 
38 | Support secure external client input and output with new instructions:
39 | 
40 | * READCLIENTPUBLICKEY
41 | * INITSECURESOCKET
42 | * RESPSECURESOCKET
43 | 
44 | ### Read/Write secret shares to disk to support persistence in a SPDZ MPC program.
45 | 
46 | Added compiler instructions:
47 | 
48 | * READFILESHARE
49 | * WRITEFILESHARE
50 | 
51 | ### Other instructions
52 | 
53 | Added compiler instructions:
54 | 
55 | * DIGESTC - Clear truncated hash computation
56 | * PRINTINT - Print register value
57 | 
58 | ## 0.0.1 (Sep 2, 2016)
59 | 
60 | ### Initial Release
61 | 
62 | * See `README.md` and `tutorial.md`.
63 | 


--------------------------------------------------------------------------------
/CONFIG:
--------------------------------------------------------------------------------
 1 | # (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | ROOT = .
 4 | 
 5 | OPTIM= -O3
 6 | #PROF = -pg
 7 | #DEBUG = -DDEBUG
 8 | #MEMPROTECT = -DMEMPROTECT
 9 | 
10 | # set this to your preferred local storage directory
11 | PREP_DIR = '-DPREP_DIR="Player-Data/"'
12 | 
13 | # set for 128-bit GF(2^n) and/or OT preprocessing
14 | USE_GF2N_LONG = 0
15 | 
16 | # set to -march=<architecture> for optimization
17 | # AVX2 support (Haswell or later) changes the bit matrix transpose
18 | ARCH = -mtune=native -mavx
19 | 
20 | #use CONFIG.mine to overwrite DIR settings
21 | -include CONFIG.mine
22 | 
23 | ifeq ($(USE_GF2N_LONG),1)
24 | GF2N_LONG = -DUSE_GF2N_LONG
25 | endif
26 | 
27 | # MAX_MOD_SZ must be at least ceil(len(p)/len(word))
28 | # Default is 2, which suffices for 128-bit p
29 | # MOD = -DMAX_MOD_SZ=2
30 | 
31 | LDLIBS = -lmpirxx -lmpir -lsodium $(MY_LDLIBS) -lm -lpthread 
32 | 
33 | ifeq ($(USE_NTL),1)
34 | LDLIBS := -lntl $(LDLIBS)
35 | endif
36 | 
37 | OS := $(shell uname -s)
38 | ifeq ($(OS), Linux)
39 | LDLIBS += -lrt
40 | endif
41 | 
42 | CXX = g++
43 | CFLAGS = $(ARCH) $(MY_CFLAGS) -g -Wextra -Wall $(OPTIM) -I$(ROOT) -pthread $(PROF) $(DEBUG) $(MOD) $(MEMPROTECT) $(GF2N_LONG) $(PREP_DIR) -maes -mpclmul -msse4.1 --std=c++11 -Werror
44 | CPPFLAGS = $(CFLAGS)
45 | LD = g++
46 | 
47 | 


--------------------------------------------------------------------------------
/Compiler/__init__.py:
--------------------------------------------------------------------------------
 1 | # (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | import compilerLib, program, instructions, types, library, floatingpoint
 4 | import inspect
 5 | from config import *
 6 | from compilerLib import run
 7 | 
 8 | 
 9 | # add all instructions to the program VARS dictionary
10 | compilerLib.VARS = {}
11 | instr_classes = [t[1] for t in inspect.getmembers(instructions, inspect.isclass)]
12 | 
13 | instr_classes += [t[1] for t in inspect.getmembers(types, inspect.isclass)\
14 |     if t[1].__module__ == types.__name__]
15 | 
16 | instr_classes += [t[1] for t in inspect.getmembers(library, inspect.isfunction)\
17 |     if t[1].__module__ == library.__name__]
18 | 
19 | for op in instr_classes:
20 |     compilerLib.VARS[op.__name__] = op
21 | 
22 | # add open and input separately due to name conflict
23 | compilerLib.VARS['open'] = instructions.asm_open
24 | compilerLib.VARS['vopen'] = instructions.vasm_open
25 | compilerLib.VARS['gopen'] = instructions.gasm_open
26 | compilerLib.VARS['vgopen'] = instructions.vgasm_open
27 | compilerLib.VARS['input'] = instructions.asm_input
28 | compilerLib.VARS['ginput'] = instructions.gasm_input
29 | 
30 | compilerLib.VARS['comparison'] = comparison
31 | compilerLib.VARS['floatingpoint'] = floatingpoint
32 | 


--------------------------------------------------------------------------------
/Compiler/compilerLib.py:
--------------------------------------------------------------------------------
 1 | # (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | from Compiler.program import Program
 4 | from Compiler.config import *
 5 | from Compiler.exceptions import *
 6 | import instructions, instructions_base, types, comparison, library
 7 | 
 8 | import random
 9 | import time
10 | import sys
11 | 
12 | 
13 | def run(args, options, param=-1, merge_opens=True, emulate=True, \
14 |             reallocate=True, assemblymode=False, debug=False):
15 |     """ Compile a file and output a Program object.
16 |     
17 |     If merge_opens is set to True, will attempt to merge any parallelisable open
18 |     instructions. """
19 |     
20 |     prog = Program(args, options, param, assemblymode)
21 |     instructions.program = prog
22 |     instructions_base.program = prog
23 |     types.program = prog
24 |     comparison.program = prog
25 |     prog.EMULATE = emulate
26 |     prog.DEBUG = debug
27 |     VARS['program'] = prog
28 |     comparison.set_variant(options)
29 |     
30 |     print 'Compiling file', prog.infile
31 |     
32 |     # no longer needed, but may want to support assembly in future (?)
33 |     if assemblymode:
34 |         prog.restart_main_thread()
35 |         for i in xrange(INIT_REG_MAX):
36 |             VARS['c%d'%i] = prog.curr_block.new_reg('c')
37 |             VARS['s%d'%i] = prog.curr_block.new_reg('s')
38 |             VARS['cg%d'%i] = prog.curr_block.new_reg('cg')
39 |             VARS['sg%d'%i] = prog.curr_block.new_reg('sg')
40 |             if i % 10000000 == 0 and i > 0:
41 |                 print "Initialized %d register variables at" % i, time.asctime()
42 |         
43 |         # first pass determines how many assembler registers are used
44 |         prog.FIRST_PASS = True
45 |         execfile(prog.infile, VARS)
46 |     
47 |     if instructions_base.Instruction.count != 0:
48 |         print 'instructions count', instructions_base.Instruction.count
49 |         instructions_base.Instruction.count = 0
50 |     prog.FIRST_PASS = False
51 |     prog.reset_values()
52 |     # make compiler modules directly accessible
53 |     sys.path.insert(0, 'Compiler')
54 |     # create the tapes
55 |     execfile(prog.infile, VARS)
56 |     
57 |     # optimize the tapes
58 |     for tape in prog.tapes:
59 |         tape.optimize(options)
60 |     
61 |     # check program still does the same thing after optimizations
62 |     if emulate:
63 |         clearmem = list(prog.mem_c)
64 |         sharedmem = list(prog.mem_s)
65 |         prog.emulate()
66 |         if prog.mem_c != clearmem or prog.mem_s != sharedmem:
67 |             print 'Warning: emulated memory values changed after compiler optimization'
68 |         #    raise CompilerError('Compiler optimization caused incorrect memory write.')
69 |     
70 |     if prog.main_thread_running:
71 |         prog.update_req(prog.curr_tape)
72 |     print 'Program requires:', repr(prog.req_num)
73 |     print 'Cost:', prog.req_num.cost()
74 |     print 'Memory size:', prog.allocated_mem
75 | 
76 |     # finalize the memory
77 |     prog.finalize_memory()
78 | 
79 |     return prog
80 | 


--------------------------------------------------------------------------------
/Compiler/config.py:
--------------------------------------------------------------------------------
 1 | # (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | from collections import defaultdict
 4 | 
 5 | #INIT_REG_MAX = 655360
 6 | INIT_REG_MAX = 1310720
 7 | REG_MAX = 2 ** 32
 8 | USER_MEM = 8192
 9 | TMP_MEM = 8192
10 | TMP_MEM_BASE = USER_MEM
11 | TMP_REG = 3
12 | TMP_REG_BASE = REG_MAX - TMP_REG
13 | 
14 | P_VALUES = { -1: 2147483713, \
15 |              32: 2147565569, \
16 |              64: 9223372036855103489, \
17 |              128: 172035116406933162231178957667602464769, \
18 |              256: 57896044624266469032429686755131815517604980759976795324963608525438406557697, \
19 |              512: 6703903964971298549787012499123814115273848577471136527425966013026501536706464354255445443244279389455058889493431223951165286470575994074291745908195329 }
20 | 
21 | BIT_LENGTHS = { -1: 32,
22 |                 32: 16,
23 |                 64: 16,
24 |                 128: 64,
25 |                 256: 64,
26 |                 512: 64 }
27 | 
28 | STAT_SEC = { -1: 6,
29 |              32: 6,
30 |              64: 30,
31 |              128: 40,
32 |              256: 40,
33 |              512: 40 }
34 | 
35 | 
36 | COST = { 'modp': defaultdict(lambda: 0,
37 |          { 'triple': 0.00020652622883106154,
38 |            'square': 0.00020652622883106154,
39 |            'bit': 0.00020652622883106154,
40 |            'inverse': 0.00020652622883106154,
41 |            'PreMulC': 2 * 0.00020652622883106154,
42 |          }),
43 |          'gf2n': defaultdict(lambda: 0,
44 |          { 'triple': 0.00020716801325875284,
45 |            'square': 0.00020716801325875284,
46 |            'inverse': 0.00020716801325875284,
47 |            'bit': 1.4492753623188405e-07,
48 |            'bittriple': 0.00004828818388140422,
49 |            'bitgf2ntriple': 0.00020716801325875284,
50 |            'PreMulC': 2 * 0.00020716801325875284,
51 |          })
52 | }
53 | 
54 | 
55 | try:
56 |     from config_mine import *
57 | except:
58 |     pass
59 | 


--------------------------------------------------------------------------------
/Compiler/exceptions.py:
--------------------------------------------------------------------------------
 1 | # (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | class CompilerError(Exception):
 4 |     """Base class for compiler exceptions."""
 5 |     pass
 6 | 
 7 | class RegisterOverflowError(CompilerError):
 8 |     pass
 9 | 
10 | class MemoryOverflowError(CompilerError):
11 |     pass
12 | 
13 | class ArgumentError(CompilerError):
14 |     """ Exception raised for errors in instruction argument parsing. """
15 |     def __init__(self, arg, msg):
16 |         self.arg = arg
17 |         self.msg = msg


--------------------------------------------------------------------------------
/Compiler/tools.py:
--------------------------------------------------------------------------------
 1 | # (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | import itertools
 4 | 
 5 | class chain(object):
 6 |     def __init__(self, *args):
 7 |         self.args = args
 8 |     def __iter__(self):
 9 |         return itertools.chain(*self.args)
10 | 


--------------------------------------------------------------------------------
/FHE/DiscreteGauss.cpp:
--------------------------------------------------------------------------------
  1 | // (C) 2018 University of Bristol. See License.txt
  2 | 
  3 | 
  4 | #include "DiscreteGauss.h"
  5 | #include "math.h"
  6 | 
  7 | void DiscreteGauss::set(double RR)
  8 | {
  9 |   R=RR;
 10 |   e=exp(1); e1=exp(0.25); e2=exp(-1.35); 
 11 | }
 12 | 
 13 | 
 14 | 
 15 | /*  Return a value distributed normaly with std dev R */
 16 | int DiscreteGauss::sample(PRNG& G, int stretch) const
 17 | {
 18 |   /*  Uses the ratio method from Wikipedia to get a 
 19 |        Normal(0,1) variable X
 20 |        Then multiplies X by R
 21 |   */
 22 |   double U,V,X,R1,R2,R3,X2;
 23 |   int ans;
 24 |   while (true)
 25 |     { U=G.get_double();
 26 |       V=G.get_double();
 27 |       R1=5-4*e1*U;
 28 |       R2=4*e2/U+1.4;
 29 |       R3=-4/log(U);
 30 |       X=sqrt(8/e)*(V-0.5)/U;
 31 |       X2=X*X;
 32 |       if (X2<=R1 || (X2<R2 && X2<=R3))
 33 |         { ans=(int) (X*R*stretch);
 34 |           return ans;
 35 |         }
 36 |     }
 37 | }
 38 | 
 39 | 
 40 | 
 41 | void RandomVectors::set(int nn,int hh,double R)
 42 | {
 43 |   n=nn;
 44 |   h=hh;
 45 |   DG.set(R);
 46 | }
 47 | 
 48 | 
 49 |  
 50 | vector<bigint> RandomVectors::sample_Gauss(PRNG& G, int stretch) const
 51 | {
 52 |   vector<bigint> ans(n);
 53 |   for (int i=0; i<n; i++)
 54 |     { ans[i]=DG.sample(G, stretch); }
 55 |   return ans;
 56 | }
 57 | 
 58 | 
 59 | vector<bigint> RandomVectors::sample_Hwt(PRNG& G) const
 60 | {
 61 |   if (h>n/2) { return sample_Gauss(G); }
 62 |   vector<bigint> ans(n);
 63 |   for (int i=0; i<n; i++) { ans[i]=0; }
 64 |   int cnt=0,j=0;
 65 |   unsigned char ch=0;
 66 |   while (cnt<h)
 67 |     { unsigned int i=G.get_uint()%n;
 68 |       if (ans[i]==0)
 69 | 	{ cnt++;
 70 |           if (j==0)
 71 |             { j=8; 
 72 |               ch=G.get_uchar();
 73 |             }
 74 |           int v=ch&1; j--;
 75 |           if (v==0) { ans[i]=-1; }
 76 |           else      { ans[i]=1;  }
 77 |         }
 78 |     }
 79 |   return ans;
 80 | }
 81 | 
 82 | 
 83 | 
 84 | 
 85 | int sample_half(PRNG& G)
 86 | {
 87 |   int v=G.get_uchar()&3;
 88 |   if (v==0 || v==1)
 89 |     return 0;
 90 |   else if (v==2)
 91 |     return 1;
 92 |   else
 93 |     return -1;
 94 | }
 95 | 
 96 | 
 97 | vector<bigint> RandomVectors::sample_Half(PRNG& G) const
 98 | {
 99 |   vector<bigint> ans(n);
100 |   for (int i=0; i<n; i++)
101 |     ans[i] = sample_half(G);
102 |   return ans;
103 | }
104 | 
105 | 
106 | vector<bigint> RandomVectors::sample_Uniform(PRNG& G,const bigint& B) const
107 | {
108 |   vector<bigint> ans(n);
109 |   bigint v;
110 |   for (int i=0; i<n; i++)
111 |     { G.get_bigint(v, numBits(B));
112 |       int bit=G.get_uint()&1;
113 |       if (bit==0) { ans[i]=v; }
114 |       else        { ans[i]=-v; }
115 |     }
116 |   return ans;
117 | }
118 | 
119 | bool RandomVectors::operator!=(const RandomVectors& other) const
120 | {
121 |   if (n != other.n or h != other.h or DG != other.DG)
122 |     return true;
123 |   else
124 |     return false;
125 | }
126 | 
127 | bool DiscreteGauss::operator!=(const DiscreteGauss& other) const
128 | {
129 |   if (other.R != R or other.e != e or other.e1 != e1 or other.e2 != e2)
130 |     return true;
131 |   else
132 |     return false;
133 | }
134 | 


--------------------------------------------------------------------------------
/FHE/FFT.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef _FFT
 4 | #define _FFT
 5 | 
 6 | /* FFT routine (mod p) for when N is a power of 2
 7 |      - We do not check that N is a power of 2 though
 8 |    This is the "classic" FFT algorithm
 9 |    theta is assumed to be an Nth root of unity
10 | 
11 |    Not tried to optimize memory thrashing though
12 | */
13 | 
14 | #include <vector>
15 | 
16 | #include "FHE/FFT_Data.h"
17 | 
18 | /* This is the basic 2^n - FFT routine, it works in an recursive 
19 |  * manner. The FFT_Iter routine below does the same thing but in 
20 |  * an iterative manner, and is therefore more efficient.
21 |  */
22 | void FFT(vector<modp>& a,int N,const modp& theta,const Zp_Data& PrD);
23 | 
24 | /* This uses a different root of unity and is used for going
25 |  * forward when doing 2^n FFT's. This avoids the need for padding
26 |  * out to a vector of size 2*n. Going backwards you still need to
27 |  * use FFT, but some other post-processing. Again the iterative
28 |  * version is given by FFT_Iter2 below, and this is usually faster
29 |  */
30 | void FFT2(vector<modp>& a,int N,const modp& theta,const Zp_Data& PrD);
31 | 
32 | template <class T,class P>
33 | void FFT_Iter(vector<T>& a,int N,const T& theta,const P& PrD);
34 | 
35 | void FFT_Iter2(vector<modp>& a,int N,const modp& theta,const Zp_Data& PrD);
36 | 
37 | 
38 | /* BFFT perform FFT and inverse FFT  mod PrD for non power of two cyclotomics.  
39 |  * The modulus in PrD (contained in FFT_Data) must be set up
40 |  * correctly in particular
41 |  *     m divides pr-1     <- Otherwise FFT not defined over base field
42 |  *     2^k divides pr-1   <- Where 2^k is the smallest power of two
43 |  *                           greater than m. This means we can do the
44 |  *                           trick of extension and the convolution using
45 |  *                           the 2-power FFT to do the main work
46 |  * forward=true  => FFT
47 |  * forward=false => inverse FFT
48 |  *
49 |  * a on input is assumed to have size less than FFTD.n (it is then zero padded)
50 |  * ans is assumed to have size FFTD.n
51 |  */                           
52 | 
53 | void BFFT(vector<modp>& ans,const vector<modp>& a,const FFT_Data& FFTD,bool forward=true);
54 | 
55 | 
56 | /* Computes the FFT via Horner's Rule
57 |    theta is assumed to be an Nth root of unity
58 |    This works for any value of N
59 | */
60 | void NaiveFFT(vector<modp>& ans,vector<modp>& a,int N,const modp& theta,const Zp_Data& PrD);
61 | 
62 | 
63 | #endif
64 | 
65 | 


--------------------------------------------------------------------------------
/FHE/FFT_Data.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef _FFT_Data
 4 | #define _FFT_Data
 5 | 
 6 | #include "Math/modp.h"
 7 | #include "Math/Zp_Data.h"
 8 | #include "Math/gfp.h"
 9 | #include "FHE/Ring.h"
10 | 
11 | /* Class for holding modular arithmetic data wrt the ring 
12 |  *
13 |  * It also holds the ring
14 |  */
15 | 
16 | 
17 | class FFT_Data
18 | {
19 |   Ring    R;
20 |   Zp_Data prData;
21 | 
22 |   vector<modp> root;     // 2m'th Root of Unity mod pr and it's inverse
23 | 
24 |   // When twop is equal to zero, m is a power of two
25 |   // When twop is positive it is equal to 2^e where 2^e>2*m and 2^e divides p-1
26 |   //    - In this case we can use FFTs over the base field
27 |   int  twop;             
28 | 
29 |   // Stuff for arithmetic when 2^e > 2*m and 2^e divides p-1  (i.e. twop positive)
30 |   vector<modp> two_root; // twop'th Root of Unity mod pr where twop = 2^e > 2*m
31 |                          //   - And inverse
32 |   vector< vector<modp> >  b; 
33 | 
34 |   // Stuff for arithmetic when m is a power of 2 (in which case twop=0)
35 |   modp iphi;    // 1/phi_m mod pr
36 |   vector< vector<modp> > powers,powers_i;
37 | 
38 |   public:
39 |   typedef gfp T;
40 |   typedef bigint S;
41 | 
42 |   void init(const Ring& Rg,const Zp_Data& PrD);
43 | 
44 |   void init_field() const { gfp::init_field(prData.pr); }
45 | 
46 |   void pack(octetStream& o) const;
47 |   void unpack(octetStream& o);
48 | 
49 |   void assign(const FFT_Data& FFTD);
50 | 
51 |   FFT_Data() { ; }
52 |   FFT_Data(const FFT_Data& FFTD)
53 |     { assign(FFTD); }
54 |   FFT_Data(const Ring& Rg,const Zp_Data& PrD)
55 |     { init(Rg,PrD); }
56 |   FFT_Data& operator=(const FFT_Data& FFTD)
57 |     { if (this!=&FFTD) { assign(FFTD); }
58 |       return *this;
59 |     }
60 | 
61 |   const Zp_Data& get_prD() const        { return prData; }
62 |   const bigint&  get_prime() const      { return prData.pr; }
63 |   int phi_m() const                     { return R.phi_m(); }
64 |   int m()     const                     { return R.m();   }
65 |   int num_slots() const                 { return R.phi_m(); }
66 | 
67 |   int p(int i)      const        { return R.p(i);     }
68 |   int p_inv(int i)  const        { return R.p_inv(i); }
69 |   const vector<int>& Phi() const { return R.Phi();    }
70 | 
71 |   int get_twop() const           { return twop;       }
72 |   modp get_root(int i) const     { return root[i];    }
73 |   modp get_iphi() const          { return iphi;       }
74 | 
75 |   const Ring& get_R() const      { return R; }
76 | 
77 |   bool operator==(const FFT_Data& other) const { return not (*this != other); }
78 |   bool operator!=(const FFT_Data& other) const;
79 | 
80 |   friend ostream& operator<<(ostream& s,const FFT_Data& FFTD); 
81 |   friend istream& operator>>(istream& s,FFT_Data& FFTD); 
82 | 
83 |   friend void BFFT(vector<modp>& ans,const vector<modp>& a,const FFT_Data& FFTD,bool forward);
84 | };
85 | 
86 | #endif
87 | 
88 | 


--------------------------------------------------------------------------------
/FHE/FHE_Params.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | 
 4 | #include "FHE_Params.h"
 5 | #include "FHE/Ring_Element.h"
 6 | #include "Math/gfp.h"
 7 | #include "Exceptions/Exceptions.h"
 8 | 
 9 | 
10 | void FHE_Params::set(const Ring& R,
11 |                      const vector<bigint>& primes,double r,int hwt)
12 | {
13 |   if (primes.size() != FFTData.size())
14 |     throw runtime_error("wrong number of primes");
15 | 
16 |   for (size_t i = 0; i < FFTData.size(); i++)
17 |     FFTData[i].init(R,primes[i]);
18 | 
19 |   Chi.set(R.phi_m(),hwt,r);
20 | 
21 |   set_sec(40);
22 | }
23 | 
24 | void FHE_Params::set_sec(int sec)
25 | {
26 |   sec_p=sec;
27 |   Bval=1;  Bval=Bval<<sec_p;
28 |   Bval=FFTData[0].get_prime()/(2*(1+Bval));
29 |   if (Bval == 0)
30 |     throw runtime_error("distributed decryption bound is zero");
31 | }
32 | 
33 | bigint FHE_Params::Q() const
34 | {
35 |   bigint res = FFTData[0].get_prime();
36 |   for (size_t i = 1; i < FFTData.size(); i++)
37 |     res *= FFTData[i].get_prime();
38 |   return res;
39 | }
40 | 
41 | void FHE_Params::pack(octetStream& o) const
42 | {
43 |   o.store(FFTData.size());
44 |   for(auto& fd: FFTData)
45 |     fd.pack(o);
46 |   Chi.pack(o);
47 |   Bval.pack(o);
48 |   o.store(sec_p);
49 | }
50 | 
51 | void FHE_Params::unpack(octetStream& o)
52 | {
53 |   size_t size;
54 |   o.get(size);
55 |   FFTData.resize(size);
56 |   for (auto& fd : FFTData)
57 |     fd.unpack(o);
58 |   Chi.unpack(o);
59 |   Bval.unpack(o);
60 |   o.get(sec_p);
61 | }
62 | 
63 | bool FHE_Params::operator!=(const FHE_Params& other) const
64 | {
65 |   if (FFTData != other.FFTData or Chi != other.Chi or sec_p != other.sec_p
66 |       or Bval != other.Bval)
67 |     {
68 |       return true;
69 |     }
70 |   else
71 |     return false;
72 | }
73 | 


--------------------------------------------------------------------------------
/FHE/FHE_Params.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef _FHE_Params
 4 | #define _FHE_Params
 5 | 
 6 | /* Class to hold the FHE Parameters 
 7 |  *
 8 |  * The idea is that there is a single global FHE_Params structure
 9 |  * called params; which holds all the data
10 |  *
11 |  * Likewise initialising params sets up all the data for other
12 |  * classes such the global ring etc
13 |  *
14 |  */
15 | #include "FHE/FFT_Data.h"
16 | #include "FHE/DiscreteGauss.h"
17 | #include "Tools/random.h"
18 | 
19 | class FHE_Params
20 | {
21 |   protected:
22 |   // Pair of moduli in FFTData[0] and FFTData[1] for the levels
23 |   vector<FFT_Data> FFTData;
24 | 
25 |   // Random generator for Multivariate Gaussian Distribution etc
26 |   RandomVectors Chi;
27 | 
28 |   // Data for distributed decryption
29 |   int sec_p;
30 |   bigint Bval;
31 | 
32 |   public:
33 | 
34 |   FHE_Params(int n_mults = 1) : FFTData(n_mults + 1), sec_p(-1) {}
35 | 
36 |   int n_mults() const { return FFTData.size() - 1; }
37 | 
38 |   // Rely on default copy assignment/constructor (not that they should
39 |   // ever be needed)
40 | 
41 |   void set(const Ring& R,const vector<bigint>& primes,double r=3.2,int hwt=64);
42 |   void set_sec(int sec);
43 | 
44 |   vector<bigint> sampleGaussian(PRNG& G, int noise_boost = 1) const
45 |      { return Chi.sample_Gauss(G, noise_boost); }
46 |   vector<bigint> sampleHwt(PRNG& G)      const   
47 |      { return Chi.sample_Hwt(G); }
48 |   vector<bigint> sampleHalf(PRNG& G)     const   
49 |      { return Chi.sample_Half(G); }
50 |   vector<bigint> sampleUniform(PRNG& G,const bigint& Bd) const
51 |      { return Chi.sample_Uniform(G,Bd); }
52 | 
53 |   const vector<FFT_Data>& FFTD() const { return FFTData; }
54 | 
55 |   const bigint& p0() const           { return FFTData[0].get_prime(); }
56 |   const bigint& p1() const           { return FFTData[1].get_prime(); }
57 |   bigint Q() const;
58 | 
59 |   int secp() const                   { return sec_p;        }
60 |   const bigint& B() const            { return Bval;         }
61 |   double get_R() const               { return Chi.get_R();  }
62 |   DiscreteGauss get_DG() const       { return Chi.get_DG(); }
63 | 
64 |   int phi_m() const                  { return FFTData[0].phi_m(); }
65 |   const Ring& get_ring()             { return FFTData[0].get_R(); }
66 | 
67 |   void pack(octetStream& o) const;
68 |   void unpack(octetStream& o);
69 | 
70 |   bool operator!=(const FHE_Params& other) const;
71 | };
72 | 
73 | #endif
74 | 


--------------------------------------------------------------------------------
/FHE/Generator.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * Generator.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef FHE_GENERATOR_H_
 9 | #define FHE_GENERATOR_H_
10 | 
11 | #include <vector>
12 | using namespace std;
13 | 
14 | #include "Math/bigint.h"
15 | #include "Math/modp.h"
16 | 
17 | template <class T>
18 | class Generator
19 | {
20 |  public:
21 |     virtual ~Generator() {}
22 |     virtual Generator* clone() const = 0;
23 |     virtual void get(T& x) const = 0;
24 | };
25 | 
26 | template <class T>
27 | class Iterator : public Generator<T>
28 | {
29 |     const vector<T>& v;
30 |     mutable size_t i;
31 | 
32 | public:
33 |     Iterator(const vector<T>& v) : v(v), i(0) {}
34 |     Generator<T>* clone() const { return new Iterator(*this); }
35 |     void get(T& x) const { x = v[i]; i++; }
36 | };
37 | 
38 | class ConversionIterator : public Generator<bigint>
39 | {
40 |     const vector<modp>& v;
41 |     const Zp_Data& ZpD;
42 |     mutable size_t i;
43 | 
44 | public:
45 |     ConversionIterator(const vector<modp>& v, const Zp_Data& ZpD) : v(v), ZpD(ZpD), i(0) {}
46 |     Generator<bigint>* clone() const { return new ConversionIterator(*this); }
47 |     void get(bigint& x) const { to_bigint(x, v[i], ZpD); i++; }
48 | };
49 | 
50 | class WriteConversionIterator : public Generator<bigint>
51 | {
52 |     vector<modp>& v;
53 |     const Zp_Data& ZpD;
54 |     mutable size_t i;
55 |     mutable bigint tmp;
56 | 
57 | public:
58 |     WriteConversionIterator(vector<modp>& v, const Zp_Data& ZpD) : v(v), ZpD(ZpD), i(0) {}
59 |     Generator<bigint>* clone() const { return new WriteConversionIterator(*this); }
60 |     void get(bigint& x) const { tmp = x; v[i].convert_destroy(tmp, ZpD); i++; }
61 | };
62 | 
63 | #endif /* FHE_GENERATOR_H_ */
64 | 


--------------------------------------------------------------------------------
/FHE/Matrix.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | 
 4 | #ifndef _myHNF
 5 | #define _myHNF
 6 | 
 7 | #include <vector>
 8 | using namespace std;
 9 | 
10 | #include "Math/bigint.h"
11 | #include "Math/modp.h"
12 | 
13 | typedef vector< vector<bigint> > matrix;
14 | typedef vector< vector<modp> > modp_matrix;
15 | 
16 | class imatrix : public vector< vector<int> >
17 | {
18 | public:
19 |     bool operator!=(const imatrix& other) const;
20 | 
21 |     void pack(octetStream& o) const;
22 |     void unpack(octetStream& o);
23 | };
24 | 
25 | /* Uses Algorithm 2.7 from Pohst-Zassenhaus to compute H and U st
26 | 		H = HNF(A) = A*U
27 | */
28 | void HNF(matrix& H,matrix& U,const matrix& A);
29 | 
30 | /* S = U*A*V
31 |    We dont care about U though
32 | */
33 | void SNF(matrix& S,const matrix& A,matrix& V);
34 | 
35 | void print(const matrix& S);
36 | void print(const imatrix& S);
37 | 
38 | // Special inverse routine, assumes A is unimodular and only
39 | // requires column operations to create the inverse
40 | matrix inv(const matrix& A);
41 | 
42 | // Another special routine for modp matrices. 
43 | // Solves
44 | // 	Ax=b
45 | // Assumes A is unimodular, square and only requires row operations to
46 | // create the inverse. In put is C=(A||b) and the routines alters A
47 | vector<modp> solve(modp_matrix& C,const Zp_Data& PrD);
48 | 
49 | // Finds a pseudo-inverse of a matrix A modulo 2
50 | //   - Input matrix is assumed to have more rows than columns
51 | void pinv(imatrix& Ai,const imatrix& A);
52 | 
53 | ostream& operator<<(ostream& s,const imatrix& A);
54 | istream& operator>>(istream& s,imatrix& A);
55 | 
56 | #endif
57 | 


--------------------------------------------------------------------------------
/FHE/NTL-Subs.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef _NTL_Subs
 4 | #define _NTL_Subs
 5 | 
 6 | /* All these routines use NTL on the inside */
 7 | 
 8 | #include "FHE/Ring.h"
 9 | #include "FHE/FFT_Data.h"
10 | #include "FHE/P2Data.h"
11 | #include "FHE/PPData.h"
12 | #include "FHE/FHE_Params.h"
13 | 
14 | 
15 | /* Routines to set up key sizes given the number of players n
16 |  *  - And size lgp of plaintext modulus p for the char p case
17 |  */
18 | 
19 | // Main setup routine (need NTL if online_only is false)
20 | void generate_setup(int nparties, int lgp, int lg2,
21 |     int sec, bool skip_2 = false, int slack = 0, bool round_up = false);
22 | 
23 | template <class FD>
24 | void generate_setup(int n_parties, int plaintext_length, int sec,
25 |     FHE_Params& params, FD& FTD, int slack, bool round_up);
26 | 
27 | // semi-homomorphic, includes slack
28 | template <class FD>
29 | int generate_semi_setup(int plaintext_length, int sec,
30 |     FHE_Params& params, FD& FieldD, bool round_up);
31 | 
32 | // field-independent semi-homomorphic setup
33 | int common_semi_setup(FHE_Params& params, int m, bigint p, int lgp0, int lgp1,
34 |     bool round_up);
35 | 
36 | // Everything else needs NTL
37 | void init(Ring& Rg,int m);
38 | void init(P2Data& P2D,const Ring& Rg);
39 | 
40 | // For use when we only care about p being of a certain size
41 | void SPDZ_Data_Setup_Char_p(Ring& R, FFT_Data& FTD, bigint& pr0, bigint& pr1,
42 |     int n, int lgp, int sec, int slack = 0, bool round_up = false);
43 | 
44 | // For use when we want p to be a specific value 
45 | void SPDZ_Data_Setup_Char_p_General(Ring& R, PPData& PPD, bigint& pr0,
46 |     bigint& pr1, int n, int sec, bigint& p);
47 | 
48 | // generate moduli according to lengths and other parameters
49 | void generate_moduli(bigint& pr0, bigint& pr1, const int m,
50 |         const bigint p, const int lg2p0, const int lg2p1);
51 | 
52 | void generate_modulus(bigint& pr, const int m, const bigint p, const int lg2pr,
53 |     const string& i = "0", const bigint& pr0 = 0);
54 | 
55 | // pre-generated dimensions for characteristic 2
56 | void char_2_dimension(int& m, int& lg2);
57 | 
58 | void SPDZ_Data_Setup_Char_2(Ring& R, P2Data& P2D, bigint& pr0, bigint& pr1,
59 |     int n, int lg2, int sec = -1, int slacke = 0, bool round_up = false);
60 | 
61 | // try to avoid expensive generation by loading from disk if possible
62 | void load_or_generate(P2Data& P2D, const Ring& Rg);
63 | 
64 | int phi_N(int N);
65 | 
66 | #endif
67 | 


--------------------------------------------------------------------------------
/FHE/NoiseBounds.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * NoiseBound.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef FHE_NOISEBOUNDS_H_
 9 | #define FHE_NOISEBOUNDS_H_
10 | 
11 | #include "Math/bigint.h"
12 | 
13 | int phi_N(int N);
14 | 
15 | class SemiHomomorphicNoiseBounds
16 | {
17 | protected:
18 |     const bigint p;
19 |     const int phi_m;
20 |     const int n;
21 |     const int sec;
22 |     int slack;
23 |     const double sigma;
24 |     const int h;
25 | 
26 |     bigint B_clean;
27 |     bigint B_scale;
28 |     bigint drown;
29 | 
30 | public:
31 |     SemiHomomorphicNoiseBounds(const bigint& p, int phi_m, int n, int sec,
32 |             int slack, bool extra_h = false, double sigma = 3.2, int h = 64);
33 |     // with scaling
34 |     bigint min_p0(const bigint& p1);
35 |     // without scaling
36 |     bigint min_p0();
37 |     bigint min_p0(bool scale, const bigint& p1) { return scale ? min_p0(p1) : min_p0(); }
38 |     static double min_phi_m(int log_q);
39 | };
40 | 
41 | // as per ePrint 2012:642 for slack = 0
42 | class NoiseBounds : public SemiHomomorphicNoiseBounds
43 | {
44 |     bigint B_KS;
45 | 
46 | public:
47 |     NoiseBounds(const bigint& p, int phi_m, int n, int sec, int slack,
48 |             double sigma = 3.2, int h = 64);
49 |     bigint U1(const bigint& p0, const bigint& p1);
50 |     bigint U2(const bigint& p0, const bigint& p1);
51 |     bigint min_p0(const bigint& p0, const bigint& p1);
52 |     bigint min_p0(const bigint& p1);
53 |     bigint min_p1();
54 |     bigint opt_p1();
55 |     bigint opt_p0() { return min_p0(opt_p1()); }
56 |     double optimize(int& lg2p0, int& lg2p1);
57 | };
58 | 
59 | #endif /* FHE_NOISEBOUNDS_H_ */
60 | 


--------------------------------------------------------------------------------
/FHE/P2Data.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef _P2Data
 4 | #define _P2Data
 5 | 
 6 | /* This class defines all the data needed for representing
 7 |  * plaintexts modulo 2
 8 |  */
 9 | 
10 | #include "FHE/Ring.h"
11 | #include "FHE/Matrix.h"
12 | #include "Math/gf2n.h"
13 | 
14 | class P2Data
15 | {
16 |   int slots;
17 |   // Data for the forward mapping  (phi_m by (slots*gf2n:deg))
18 |   imatrix A;
19 |   // Data for the backward mapping (phi_m by phi_m)
20 |   imatrix Ai;
21 | 
22 |   public:
23 |   typedef gf2n_short T;
24 |   typedef int S;
25 | 
26 |   int num_slots() const { return slots; }
27 |   int degree() const { return A.size() ? A[0].size() : 0; }
28 |   int phi_m() const { return A.size(); }
29 | 
30 |   void check_dimensions() const;
31 | 
32 |   // Despite only dealing with bits, we still use bigint's so
33 |   // we can easily dovetail into the FHE code
34 |   void forward(vector<int>& ans,const vector<gf2n_short>& a) const;
35 |   void backward(vector<gf2n_short>& ans,const vector<int>& a) const;
36 | 
37 |   int get_prime() const { return 2; }
38 | 
39 |   bool operator!=(const P2Data& other) const;
40 | 
41 |   // no op because we require field to be initalized first
42 |   void init_field() const {}
43 | 
44 |   void pack(octetStream& o) const;
45 |   void unpack(octetStream& o);
46 | 
47 |   void load(const Ring& Rg);
48 |   void store(const Ring& Rg) const;
49 | 
50 |   void load_or_generate(const Ring& Rg);
51 | 
52 |   friend ostream& operator<<(ostream& s,const P2Data& P2D);
53 |   friend istream& operator>>(istream& s,P2Data& P2D);
54 | 
55 |   friend void init(P2Data& P2D,const Ring& Rg);
56 | };
57 | 
58 | #endif
59 | 
60 | 


--------------------------------------------------------------------------------
/FHE/PPData.cpp:
--------------------------------------------------------------------------------
  1 | // (C) 2018 University of Bristol. See License.txt
  2 | 
  3 | #include "Math/Subroutines.h"
  4 | #include "FHE/PPData.h"
  5 | #include "FHE/FFT.h"
  6 | #include "FHE/Matrix.h"
  7 | 
  8 | 
  9 | 
 10 | void PPData::assign(const PPData& PPD)
 11 | {
 12 |   R=PPD.R;
 13 |   prData=PPD.prData;
 14 |   root=PPD.root;
 15 | }
 16 | 
 17 | 
 18 | void PPData::init(const Ring& Rg,const Zp_Data& PrD)
 19 | {
 20 |   R=Rg;
 21 |   prData=PrD;
 22 | 
 23 |   root=Find_Primitive_Root_m(Rg.m(),Rg.Phi(),PrD);
 24 | }
 25 |     
 26 | 
 27 | ostream& operator<<(ostream& s,const PPData& PPD)
 28 | {
 29 |   bigint ans;
 30 |   s << PPD.prData << endl;
 31 |   s << PPD.R << endl;
 32 |   to_bigint(ans,PPD.root,PPD.prData); s << ans << " ";
 33 | 
 34 |   return s;
 35 | }
 36 | 
 37 | 
 38 | istream& operator>>(istream& s,PPData& PPD)
 39 | {
 40 |   bigint ans;
 41 |   s >> PPD.prData >> PPD.R;
 42 |   s >> ans; to_modp(PPD.root,ans,PPD.prData);
 43 |   return s;
 44 | }
 45 | 
 46 | 
 47 | 
 48 | void PPData::to_eval(vector<modp>& elem) const
 49 | {
 50 |   if (elem.size()!= (unsigned) R.phi_m())
 51 |     { throw params_mismatch(); }
 52 | 
 53 |   throw not_implemented();
 54 | 
 55 | /*
 56 |   vector<modp> ans; 
 57 |   ans.resize(R.phi_m());
 58 |   modp x=root;
 59 |   for (int i=0; i<R.phi_m(); i++)
 60 |     { ans[i]=elem[R.phi_m()-1];
 61 |       for (int j=1; j<R.phi_m(); j++)
 62 | 	{ Mul(ans[i],ans[i],x,prData);
 63 |           Add(ans[i],ans[i],elem[R.phi_m()-j-1],prData);
 64 | 	}
 65 |       Mul(x,x,root,prData);
 66 |     }
 67 |   elem=ans;
 68 | */
 69 | }
 70 | 
 71 | void PPData::from_eval(vector<modp>& elem) const
 72 | {
 73 |   // avoid warning
 74 |   elem.empty();
 75 |   throw not_implemented();
 76 | 
 77 |   /*
 78 |   modp_matrix A;
 79 |   int n=phi_m();
 80 |   A.resize(n, vector<modp>(n+1) );
 81 |   modp x=root;
 82 |   for (int i=0; i<n; i++)
 83 |     { assignOne(A[0][i],prData);
 84 |       for (int j=1; j<n; j++)
 85 |          { Mul(A[j][i],A[j-1][i],x,prData); }
 86 |       Mul(x,x,root,prData);
 87 |       A[i][n]=elem[i];
 88 |     }
 89 |   elem=solve(A,prData);
 90 |   */
 91 | 	
 92 | }
 93 | 
 94 | 
 95 | void PPData::reset_iteration()
 96 | {
 97 |   pow=1; theta.assign(root); thetaPow=theta; 
 98 | }
 99 | 
100 | void PPData::next_iteration()
101 | {
102 |   do
103 |     { thetaPow.mul(theta);
104 |       pow++;
105 |     }
106 |   while (gcd(pow,m())!=1);
107 | 
108 | 
109 | }
110 | 
111 | 
112 | gfp PPData::get_evaluation(const vector<bigint>& mess) const
113 | {
114 |   // Uses Horner's rule
115 |   gfp ans;
116 |   to_gfp(ans,mess[mess.size()-1]);
117 |   gfp coeff;
118 |   for (int j=mess.size()-2; j>=0; j--)
119 |         { ans.mul(thetaPow);
120 |           to_gfp(coeff,mess[j]);
121 |           ans.add(coeff);
122 |         }
123 |   return ans;
124 | }
125 | 
126 | 
127 | 


--------------------------------------------------------------------------------
/FHE/PPData.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef _PPData
 4 | #define _PPData
 5 | 
 6 | #include "Math/modp.h"
 7 | #include "Math/Zp_Data.h"
 8 | #include "Math/gfp.h"
 9 | #include "FHE/Ring.h"
10 | 
11 | /* Class for holding modular arithmetic data wrt the ring 
12 |  *
13 |  * It also holds the ring
14 |  */
15 | 
16 | class PPData
17 | {
18 |   public:
19 |   typedef gf2n_short T;
20 |   typedef bigint S;
21 | 
22 |   Ring    R;
23 |   Zp_Data prData;
24 | 
25 |   modp root;        // m'th Root of Unity mod pr 
26 |   
27 |   void init(const Ring& Rg,const Zp_Data& PrD);
28 | 
29 |   void assign(const PPData& PPD);
30 | 
31 |   PPData() { ; }
32 |   PPData(const PPData& PPD)
33 |     { assign(PPD); }
34 |   PPData(const Ring& Rg,const Zp_Data& PrD)
35 |     { init(Rg,PrD); }
36 |   PPData& operator=(const PPData& PPD)
37 |     { if (this!=&PPD) { assign(PPD); }
38 |       return *this;
39 |     }
40 | 
41 |   const Zp_Data& get_prD() const   { return prData; }
42 |   const bigint&  get_prime() const { return prData.pr; }
43 |   int phi_m() const                { return R.phi_m(); }
44 |   int m()     const                { return R.m();   }
45 |   int num_slots() const { return R.phi_m(); }
46 |   
47 | 
48 |   int p(int i)      const        { return R.p(i);     }
49 |   int p_inv(int i)  const        { return R.p_inv(i); }
50 |   const vector<int>& Phi() const { return R.Phi();    }
51 | 
52 |   friend ostream& operator<<(ostream& s,const PPData& PPD); 
53 |   friend istream& operator>>(istream& s,PPData& PPD); 
54 | 
55 |   // Convert input vector from poly to evaluation representation
56 |   //   - Uses naive method and not FFT, we only use this rarely in any case
57 |   void to_eval(vector<modp>& elem) const;
58 |   void from_eval(vector<modp>& elem) const;
59 | 
60 |   // Following are used to iteratively get slots, as we use PPData when
61 |   // we do not have an efficient FFT algorithm
62 |   gfp thetaPow,theta;
63 |   int pow;
64 |   void reset_iteration();
65 |   void next_iteration(); 
66 |   gfp get_evaluation(const vector<bigint>& mess) const;
67 |   
68 | };
69 | 
70 | #endif
71 | 
72 | 


--------------------------------------------------------------------------------
/FHE/QGroup.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef _QGroup
 4 | #define _QGroup
 5 | 
 6 | /* This class holds the data needed to represent
 7 | 	Gal/G_2
 8 |    where G_2 is the decomposition group at 2 and Gal=(Z/mZ)^*
 9 | 
10 |    We hold it as a set of generators g[i] and orders d[i]
11 | 
12 |    The group is created using a Hafner-McCurley style
13 |    generator/relation algorithm, then we apply the SNF.
14 |    The key thing is that we impose the relation 2=1 so
15 |    as to get the quotient group above
16 | */
17 | 
18 | #include <iostream>
19 | #include <vector>
20 | using namespace std;
21 | 
22 | class QGroup
23 | {
24 |    int m;           // the integer m defines the group (Z/mZ)^*/<2>
25 |    vector<int> g;   // g is an array of generators
26 |    vector<int> d;   /* d is an array of group orders, such that
27 | 	             *   (Z/mZ)^* = C_d0 \times C_d1 \times ...
28 |                      * and gi generates an order-di group
29 | 	             *******************************************/
30 |    int ngen; // the number of generators
31 |    int Gord;
32 |    mutable vector<int> elems;
33 | 
34 |    public:
35 |  
36 |    void assign(int mm,int seed); // initialize this instance for m=mm
37 | 
38 |    QGroup()  { ; }
39 |    ~QGroup() { ; }
40 |    
41 |    int num_gen()      const { return ngen; }
42 |    int gen(int i)     const { return g[i]; }
43 |    int gord(int i)    const { return d[i]; }
44 |    int order()        const { return Gord;  }
45 | 
46 |    friend ostream& operator<<(ostream& s,const QGroup& QGrp);
47 |    friend istream& operator>>(istream& s,QGroup& QGrp);
48 | 
49 |    // For 0 <= n < ord returns the nth element
50 |    int nth_element(int n) const;
51 | };
52 | 
53 | #endif
54 | 


--------------------------------------------------------------------------------
/FHE/Random_Coins.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | 
 4 | #include "Random_Coins.h"
 5 | #include "FHE_Keys.h"
 6 | 
 7 | Int_Random_Coins::Int_Random_Coins(const FHE_PK& pk) :
 8 |     Int_Random_Coins(pk.get_params())
 9 | {
10 | }
11 | 
12 | Random_Coins::Random_Coins(const FHE_PK& pk) :
13 |     Random_Coins(pk.get_params())
14 | {
15 | }
16 | 
17 | void add(Random_Coins& ans,const Random_Coins& x,const Random_Coins& y)
18 | { 
19 |   if (x.params!=y.params)   { throw params_mismatch(); }
20 |   if (ans.params!=y.params) { throw params_mismatch(); }
21 | 
22 |   add(ans.uu,x.uu,y.uu); 
23 |   add(ans.vv,x.vv,y.vv); 
24 |   add(ans.ww,x.ww,y.ww); 
25 | }
26 | 
27 | 


--------------------------------------------------------------------------------
/FHE/Random_Coins.h:
--------------------------------------------------------------------------------
  1 | // (C) 2018 University of Bristol. See License.txt
  2 | 
  3 | #ifndef _Random_Coins
  4 | #define _Random_Coins
  5 | 
  6 | /*  Randomness used to encrypt */
  7 | 
  8 | #include "FHE/FHE_Params.h"
  9 | #include "FHE/Rq_Element.h"
 10 | #include "FHE/AddableVector.h"
 11 | 
 12 | class FHE_PK;
 13 | 
 14 | class Int_Random_Coins : public AddableMatrix<bigint>
 15 | {
 16 |   const FHE_Params* params;
 17 | public:
 18 |   Int_Random_Coins(const FHE_Params& params) : params(&params)
 19 |   { resize(3, params.phi_m()); }
 20 | 
 21 |   Int_Random_Coins(const FHE_PK& pk);
 22 | 
 23 |   void sample(PRNG& G)
 24 |   {
 25 |     (*this)[0].from(HalfGenerator(G));
 26 |     for (int i = 1; i < 3; i++)
 27 |       (*this)[i].from(GaussianGenerator(params->get_DG(), G));
 28 |   }
 29 | };
 30 | 
 31 | class Random_Coins
 32 | {
 33 |   Rq_Element uu,vv,ww;
 34 |   const FHE_Params *params;
 35 | 
 36 |   public:
 37 | 
 38 |   const FHE_Params& get_params() const { return *params; }
 39 | 
 40 |   Random_Coins(const FHE_Params& p) 
 41 |     : uu(p.FFTD(),evaluation,evaluation),
 42 |       vv(p.FFTD(),evaluation,evaluation),
 43 |       ww(p.FFTD(),polynomial,polynomial)
 44 |       { params=&p; }
 45 | 
 46 |   Random_Coins(const FHE_PK& pk);
 47 | 
 48 |   ~Random_Coins() { ; }
 49 |   
 50 |   // Rely on default copy assignment/constructor
 51 | 
 52 |   const Rq_Element& u() const { return uu; }
 53 |   const Rq_Element& v() const { return vv; }
 54 |   const Rq_Element& w() const { return ww; }
 55 | 
 56 |   void assign(const Rq_Element& u,const Rq_Element& v,const Rq_Element& w)
 57 |     { uu=u; vv=v; ww=w; }
 58 | 
 59 |   template <class T>
 60 |   void assign(const vector<T>& u,const vector<T>& v,const vector<T>& w)
 61 |     { uu.from_vec(u); vv.from_vec(v); ww.from_vec(w); }
 62 | 
 63 |   void assign(const Int_Random_Coins& rc)
 64 |   { uu.from_vec(rc[0]); vv.from_vec(rc[1]); ww.from_vec(rc[2]); }
 65 | 
 66 |   /* Generate a standard distribution */
 67 |   void generate(PRNG& G)
 68 |     { uu.from(HalfGenerator(G));
 69 |       vv.from(GaussianGenerator(params->get_DG(), G));
 70 |       ww.from(GaussianGenerator(params->get_DG(), G));
 71 |     }
 72 | 
 73 |   // Generate all from Uniform in range (-B,...B)
 74 |   void generateUniform(PRNG& G,const bigint& B1,const bigint& B2,const bigint& B3)
 75 |     {
 76 |       if (B1 == 0)
 77 |         uu.assign_zero();
 78 |       else
 79 |         uu.from(UniformGenerator(G,numBits(B1)));
 80 |       vv.from(UniformGenerator(G,numBits(B2)));
 81 |       ww.from(UniformGenerator(G,numBits(B3)));
 82 |     }
 83 | 
 84 | 
 85 |   // ans,x and y must have same params otherwise error
 86 |   friend void add(Random_Coins& ans,
 87 |                   const Random_Coins& x,const Random_Coins& y);
 88 | 
 89 |   // Don't bother outputing params, assumes these are implicitly known
 90 |   friend ostream& operator<<(ostream& s,const Random_Coins& rc)
 91 |     { s << rc.uu << " " << rc.vv << " " << rc.ww;
 92 |       return s;
 93 |     }
 94 | 
 95 |   void pack(octetStream& o) const { uu.pack(o); vv.pack(o); ww.pack(o); }
 96 | 
 97 |   size_t report_size(ReportType type)
 98 |   { return uu.report_size(type) + vv.report_size(type) + ww.report_size(type); }
 99 | };
100 | 
101 | 
102 | #endif
103 | 


--------------------------------------------------------------------------------
/FHE/Ring.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | 
 4 | #include "Ring.h"
 5 | #include "Exceptions/Exceptions.h"
 6 | 
 7 | ostream& operator<<(ostream& s,const Ring& R)
 8 | {
 9 |   s << R.mm << " " << R.phim << endl;
10 |   for (int i=0; i<R.phim; i++)  { s << R.pi[i] << " "; }
11 |   s << endl;
12 |   for (int i=0; i<R.mm; i++)    { s << R.pi_inv[i] << " "; }
13 |   s << endl;
14 |   for (int i=0; i<=R.phim; i++) { s << R.poly[i] << " "; }
15 |   s << endl;
16 |   return s;
17 | }
18 | 
19 | istream& operator>>(istream& s,Ring& R)
20 | {
21 |   s >> R.mm >> R.phim;
22 |   if (s.fail())
23 |     throw IO_Error("can't read ring");
24 |   R.pi.resize(R.phim); R.pi_inv.resize(R.mm); R.poly.resize(R.phim+1);
25 |   for (int i=0; i<R.phim; i++)  { s >> R.pi[i]; }
26 |   for (int i=0; i<R.mm; i++)    { s >> R.pi_inv[i]; }
27 |   for (int i=0; i<=R.phim; i++) { s >> R.poly[i]; }
28 |   return s;
29 | }
30 | 
31 | void Ring::pack(octetStream& o) const
32 | {
33 |   o.store(mm);
34 |   o.store(phim);
35 |   o.store(pi);
36 |   o.store(pi_inv);
37 |   o.store(poly);
38 | }
39 | 
40 | void Ring::unpack(octetStream& o)
41 | {
42 |   o.get(mm);
43 |   o.get(phim);
44 |   o.get(pi);
45 |   o.get(pi_inv);
46 |   o.get(poly);
47 | }
48 | 
49 | bool Ring::operator !=(const Ring& other) const
50 | {
51 |   if (mm != other.mm or phim != other.phim or pi != other.pi
52 |       or pi_inv != other.pi_inv or poly != other.poly)
53 |     return true;
54 |   else
55 |     return false;
56 | }
57 | 


--------------------------------------------------------------------------------
/FHE/Ring.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef _Ring
 4 | #define _Ring
 5 | 
 6 | /* Class to define the basic ring we are working with
 7 |  * and any associated data
 8 |  */
 9 | 
10 | #include <vector>
11 | #include <iostream>
12 | using namespace std;
13 | 
14 | #include "Tools/octetStream.h"
15 | 
16 | class Ring
17 | {
18 |   int mm,phim;
19 |   vector<int> pi;
20 |   vector<int> pi_inv;
21 |   vector<int> poly;
22 |   
23 |   public:
24 | 
25 | 
26 |   Ring() : mm(0), phim(0) { ; }
27 |   ~Ring()     { ; }
28 | 
29 |   // Rely on default copy assignment/constructor
30 |   
31 |   int phi_m() const { return phim; }
32 |   int m()     const { return mm;   }
33 | 
34 |   int p(int i)      const { return pi.at(i);     }
35 |   int p_inv(int i)  const { return pi_inv.at(i); }
36 |   const vector<int>& Phi() const { return poly;         }
37 | 
38 |   friend ostream& operator<<(ostream& s,const Ring& R);
39 |   friend istream& operator>>(istream& s,Ring& R);
40 | 
41 |   friend void init(Ring& Rg,int m);
42 | 
43 |   void pack(octetStream& o) const;
44 |   void unpack(octetStream& o);
45 | 
46 |   bool operator!=(const Ring& other) const;
47 | };
48 | 
49 | #endif
50 | 
51 | 


--------------------------------------------------------------------------------
/FHE/tools.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * tools.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef FHE_TOOLS_H_
 9 | #define FHE_TOOLS_H_
10 | 
11 | #include <vector>
12 | using namespace std;
13 | 
14 | template <class T>
15 | T sum(const vector<T>& summands)
16 | {
17 |     T res = summands[0];
18 |     for (size_t i = 1; i < summands.size(); i++)
19 |         res += summands[i];
20 |     return res;
21 | }
22 | 
23 | #endif /* FHE_TOOLS_H_ */
24 | 


--------------------------------------------------------------------------------
/FHEOffline/CutAndChooseMachine.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * CutAndChooseMachine.cpp
 5 |  *
 6 |  */
 7 | 
 8 | #include "FHEOffline/CutAndChooseMachine.h"
 9 | #include "FHEOffline/SimpleGenerator.h"
10 | 
11 | CutAndChooseMachine::CutAndChooseMachine(int argc, const char** argv)
12 | {
13 |     opt.add(
14 |           "", // Default.
15 |           0, // Required?
16 |           0, // Number of args expected.
17 |           0, // Delimiter if expecting multiple args.
18 |           "Use covert security (default: active; use -s for parameter)", // Help description.
19 |           "-c", // Flag token.
20 |           "--covert" // Flag token.
21 |     );
22 |     parse_options(argc, argv);
23 |     covert = opt.isSet("--covert");
24 |     if (not covert and sec != 40)
25 |         throw runtime_error("active cut-and-choose only implemented for 40-bit security");
26 |     if (covert)
27 |         generate_setup(COVERT_SPDZ2_SLACK);
28 |     else
29 |         generate_setup(ACTIVE_SPDZ2_SLACK);
30 |     for (int i = 0; i < nthreads; i++)
31 |     {
32 |         if (use_gf2n)
33 |             generators.push_back(new_generator<P2Data>(i));
34 |         else
35 |             generators.push_back(new_generator<FFT_Data>(i));
36 |     }
37 | }
38 | 
39 | template <class FD>
40 | GeneratorBase* CutAndChooseMachine::new_generator(int i)
41 | {
42 |     SimpleGenerator<EncCommit_, FD>* generator =
43 |         new SimpleGenerator<EncCommit_, FD>(N, setup.part<FD>(), *this, i, data_type);
44 |     if (covert)
45 |         generator->EC.init(generator->P, setup.part<FD>().pk, sec, Full);
46 |     else
47 |         generator->EC.init(generator->P, setup.part<FD>().pk, Full, setup.part<FD>().FieldD, i);
48 |     return generator;
49 | }
50 | 


--------------------------------------------------------------------------------
/FHEOffline/CutAndChooseMachine.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * CutAndChooseMachine.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef FHEOFFLINE_CUTANDCHOOSEMACHINE_H_
 9 | #define FHEOFFLINE_CUTANDCHOOSEMACHINE_H_
10 | 
11 | #include "FHEOffline/SimpleMachine.h"
12 | 
13 | class CutAndChooseMachine : public MultiplicativeMachine
14 | {
15 |     bool covert;
16 | 
17 |     template <class FD>
18 |     GeneratorBase* new_generator(int i);
19 | 
20 | public:
21 |     CutAndChooseMachine(int argc, const char** argv);
22 | 
23 |     int get_covert() const { return sec; }
24 | };
25 | 
26 | #endif /* FHEOFFLINE_CUTANDCHOOSEMACHINE_H_ */
27 | 


--------------------------------------------------------------------------------
/FHEOffline/DataSetup.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * DataSetup.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef FHEOFFLINE_DATASETUP_H_
 9 | #define FHEOFFLINE_DATASETUP_H_
10 | 
11 | #include "Networking/Player.h"
12 | #include "FHE/FHE_Keys.h"
13 | #include "FHEOffline/FullSetup.h"
14 | #include "Math/Setup.h"
15 | 
16 | class DataSetup;
17 | 
18 | template <class FD>
19 | class PartSetup
20 | {
21 | public:
22 |   typedef typename FD::T T;
23 | 
24 |   FHE_Params params;
25 |   FD FieldD;
26 |   FHE_PK pk;
27 |   FHE_SK sk;
28 |   Ciphertext calpha;
29 |   typename FD::T alphai;
30 | 
31 |   PartSetup();
32 |   void generate_setup(int n_parties, int plaintext_length, int sec, int slack,
33 |       bool round_up);
34 |   void output_setup(ostream& s) const;
35 | 
36 |   void fake(vector<FHE_SK>& sks, vector<T>& alphais, int nplayers, bool distributed = true);
37 |   void fake(vector<PartSetup<FD> >& setups, int nplayers, bool distributed = true);
38 |   void insecure_debug_keys(vector<PartSetup<FD> >& setups, int nplayers, bool simple_pk);
39 | 
40 |   void pack(octetStream& os);
41 |   void unpack(octetStream& os);
42 | 
43 |   void init_field();
44 | 
45 |   void check(int sec) const;
46 |   bool operator!=(const PartSetup<FD>& other);
47 | };
48 | 
49 | class DataSetup
50 | {
51 | public:
52 |   PartSetup<FFT_Data> setup_p;
53 |   PartSetup<P2Data> setup_2;
54 | 
55 |   FHE_Params &params_p,&params_2;
56 |   FFT_Data& FTD;
57 |   P2Data& P2D;
58 | 
59 |   FHE_PK& pk_p;
60 |   FHE_SK& sk_p;
61 | 
62 |   FHE_PK& pk_2;
63 |   FHE_SK& sk_2;
64 | 
65 |   Ciphertext& calphap;
66 |   Ciphertext& calpha2;
67 | 
68 |   gfp& alphapi;
69 |   gf2n_short& alpha2i;
70 | 
71 |   DataSetup();
72 |   DataSetup(Names & N, bool skip_2 = false);
73 |   DataSetup(const DataSetup& other) : DataSetup() { *this = other; }
74 |   DataSetup& operator=(const DataSetup& other);
75 | 
76 |   void write_setup(string dir, bool skip_2);
77 |   void write_setup(bool skip_2);
78 |   void write_setup(const Names& N, bool skip_2);
79 |   string get_prep_dir(int n_parties) const;
80 |   void read_setup(bool skip_2, string dir = PREP_DIR);
81 |   void read(Names& N, bool skip_2 = false, string dir = PREP_DIR);
82 |   void output(int my_number, int nn, bool specific_dir = false);
83 |   template <class FD>
84 |   PartSetup<FD>& part();
85 | };
86 | 
87 | template<> inline PartSetup<FFT_Data>& DataSetup::part<FFT_Data>() { return setup_p; }
88 | template<> inline PartSetup<P2Data>& DataSetup::part<P2Data>() { return setup_2; }
89 | 
90 | #endif /* FHEOFFLINE_DATASETUP_H_ */
91 | 


--------------------------------------------------------------------------------
/FHEOffline/DistDecrypt.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | 
 4 | #include "DistDecrypt.h"
 5 | 
 6 | template<class FD>
 7 | DistDecrypt<FD>::DistDecrypt(const Player& P, const FHE_SK& share,
 8 |     const FHE_PK& pk, const FD& FTD) :
 9 |     P(P), share(share), pk(pk), mf(FTD), f(FTD)
10 | {
11 |   vv.resize(pk.get_params().phi_m());
12 |   vv1.resize(pk.get_params().phi_m());
13 |   // extra limb for operations
14 |   bigint limit = pk.get_params().Q() << 64;
15 |   vv.allocate_slots(limit);
16 |   vv1.allocate_slots(limit);
17 |   mf.allocate_slots(pk.get_params().p0() << 64);
18 | }
19 | 
20 | template<class FD>
21 | Plaintext_<FD>& DistDecrypt<FD>::run(const Ciphertext& ctx, bool NewCiphertext)
22 | {
23 |   const FHE_Params& params=ctx.get_params();
24 | 
25 |   share.dist_decrypt_1(vv, ctx,P.my_num(),P.num_players());
26 | 
27 |   if (not NewCiphertext)
28 |     intermediate_step();
29 | 
30 |   // Now pack into an octetStream for broadcasting
31 |   vector<octetStream> os(P.num_players());
32 | 
33 |   if ((int)vv.size() != params.phi_m())
34 |     throw length_error("wrong length of ring element");
35 |   for (int i=0; i<params.phi_m(); i++)
36 |     { (os[P.my_num()]).store(vv[i]); }
37 | 
38 |   // Broadcast and Receive the values
39 |   P.Broadcast_Receive(os);
40 | 
41 |   // Reconstruct the value mod p0 from all shares
42 |   vv1.resize(params.phi_m());
43 |   for (int i=0; i<P.num_players(); i++)
44 |     { if (i!=P.my_num())
45 |         { for (int j=0; j<params.phi_m(); j++)
46 | 	    { os[i].get(vv1[j]); }
47 | 	  share.dist_decrypt_2(vv,vv1);
48 |         }
49 |     }
50 | 
51 |   // Now get the final message
52 |   bigint mod=params.p0();
53 |   mf.set_poly_mod(vv,mod);
54 |   return mf;
55 | }
56 | 
57 | 
58 | template class DistDecrypt<FFT_Data>;
59 | template class DistDecrypt<P2Data>;
60 | 
61 | 
62 | 


--------------------------------------------------------------------------------
/FHEOffline/DistDecrypt.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef _DistDecrypt
 4 | #define _DistDecrypt
 5 | 
 6 | /*
 7 |  * This is the Distributed Decryption Protocol
 8 |  *
 9 |  */
10 | 
11 | #include "FHE/Ciphertext.h"
12 | #include "Networking/Player.h"
13 | #include "FHEOffline/Reshare.h"
14 | 
15 | template<class FD>
16 | class DistDecrypt
17 | {
18 | protected:
19 |   const Player& P;
20 |   const FHE_SK& share;
21 |   const FHE_PK& pk;
22 |   AddableVector<bigint> vv, vv1;
23 | 
24 | public:
25 |   Plaintext_<FD> mf, f;
26 | 
27 |   DistDecrypt(const Player& P, const FHE_SK& share, const FHE_PK& pk,
28 |       const FD& fd);
29 |   virtual ~DistDecrypt() {}
30 | 
31 |   Plaintext_<FD>& run(const Ciphertext& ctx, bool NewCiphertext = false);
32 |   virtual void intermediate_step() {}
33 | 
34 |   virtual void reshare(Plaintext<typename FD::T, FD, typename FD::S>& m,
35 |       const Ciphertext& cm,
36 |       EncCommitBase<typename FD::T, FD, typename FD::S>& EC)
37 |   { Ciphertext dummy(pk.get_params()); Reshare(m, dummy, cm, false, P, EC, pk, *this); }
38 | 
39 |   size_t report_size(ReportType type)
40 |   { return vv.report_size(type) + vv1.report_size(type) + mf.report_size(type) + f.report_size(type); }
41 | };
42 | 
43 | #endif
44 | 
45 | 


--------------------------------------------------------------------------------
/FHEOffline/DistKeyGen.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * DistKeyGen.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef FHEOFFLINE_DISTKEYGEN_H_
 9 | #define FHEOFFLINE_DISTKEYGEN_H_
10 | 
11 | #include "FHE/Random_Coins.h"
12 | #include "FHE/Rq_Element.h"
13 | #include "FHE/FHE_Params.h"
14 | #include "FHE/FHE_Keys.h"
15 | #include "Networking/Player.h"
16 | 
17 | void Encrypt_Rq_Element(Ciphertext& c, const Rq_Element& mess,
18 |         const Random_Coins& rc, const FHE_PK& pk);
19 | 
20 | void Run_Gen_Protocol(FHE_PK& pk, FHE_SK& sk, const Player& P, int num_runs,
21 |         bool commit);
22 | 
23 | 
24 | class DistKeyGen
25 | {
26 |     const FHE_Params& params;
27 | 
28 | public:
29 |     Random_Coins rc1, rc2;
30 |     Rq_Element secret;
31 |     Rq_Element a;
32 |     Rq_Element e;
33 |     Rq_Element b;
34 |     FHE_PK pk;
35 |     Ciphertext enc_dash;
36 |     Ciphertext enc;
37 |     bigint p;
38 | 
39 |     static void fake(FHE_PK& pk, vector<FHE_SK>& sks, const bigint& p, int nparties);
40 | 
41 |     DistKeyGen(const FHE_Params& params, const bigint& p);
42 |     void Gen_Random_Data(PRNG& G);
43 |     DistKeyGen& operator+=(const DistKeyGen& other);
44 |     void sum_a(const vector<Rq_Element>& as);
45 |     void compute_b();
46 |     void compute_enc_dash(const vector<Rq_Element>& bs);
47 |     void compute_enc_dash();
48 |     void compute_enc(const vector<Ciphertext>& enc_dashs);
49 |     void compute_enc();
50 |     void sum_enc(const vector<Ciphertext>& enc);
51 |     void finalize(FHE_PK& pk, FHE_SK& sk);
52 |     void check_equality(const DistKeyGen other);
53 | };
54 | 
55 | #endif /* FHEOFFLINE_DISTKEYGEN_H_ */
56 | 


--------------------------------------------------------------------------------
/FHEOffline/FHE-Subroutines.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | 
 4 | #include "Auth/Subroutines.h"
 5 | #include "FHE/Rq_Element.h"
 6 | #include "FHE/Ciphertext.h"
 7 | #include "Tools/Commit.h"
 8 | 
 9 | /* This runs the Commit and Open Protocol for data[i][j] of type T
10 |  *   0 <= i < num_runs
11 |  *   0 <= j < num_players
12 |  * On input data[i][j] is only defined for j=my_number
13 |  */
14 | template<class T>
15 | void Commit_And_Open(vector< vector<T> >& data,const Player& P,int num_runs)
16 | {
17 |   int num_players=P.num_players();
18 |   vector< vector<octetStream> > Comm_data(num_runs, vector<octetStream>(num_players));
19 |   vector<octetStream> Open_data(num_runs);
20 |   Commit(Comm_data,Open_data,data,P,num_runs);
21 |   Open(data,Comm_data,Open_data,P,num_runs);
22 | }
23 | 
24 | 
25 | 
26 | /* Just transmit data[i][j] of type T
27 |  *   0 <= i < num_runs
28 |  *   0 <= j < num_players
29 |  * On output data[i][j] contains all the data
30 |  */
31 | template<class T>
32 | void Transmit_Data(vector< vector<T> >& data,const Player& P,int num_runs)
33 | {
34 |   int my_number=P.my_num();
35 |   int num_players=P.num_players();
36 |   for (int i=0; i<num_runs; i++)
37 |     {
38 |       vector<octetStream> t_data(num_players);
39 |       data[i][my_number].pack(t_data[my_number]);
40 |       P.Broadcast_Receive(t_data);
41 |       for (int j=0; j<num_players; j++)
42 |         if (j!=my_number)
43 |           data[i][j].unpack(t_data[j]);
44 |     }
45 | }
46 | 
47 | 
48 | 
49 | template void Commit_And_Open(vector< vector<Rq_Element> >& data,const Player& P,int num_runs);
50 | template void Commit_And_Open(vector< vector<Ciphertext> >& data,const Player& P,int num_runs);
51 | 
52 | template void Transmit_Data(vector< vector<Rq_Element> >& data,const Player& P,int num_runs);
53 | template void Transmit_Data(vector< vector<Ciphertext> >& data,const Player& P,int num_runs);
54 | 
55 | 


--------------------------------------------------------------------------------
/FHEOffline/FullSetup.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | 
 4 | #include "FHEOffline/FullSetup.h"
 5 | #include "Math/gfp.h"
 6 | 
 7 | #include "FHE/FHE_Params.h"
 8 | #include "FHE/NTL-Subs.h"
 9 | 
10 | #include <sys/stat.h>
11 | #include <fstream>
12 | #include <sstream>
13 | using namespace std;
14 | 
15 | 
16 | // Read data for SHE offline
17 | void get_setup(FHE_Params& params_p,FFT_Data& FTD,
18 |                FHE_Params& params_2,P2Data& P2D,string dir,
19 |                bool skip_2)
20 | {
21 |   int lg2;
22 |   Ring R2,Rp;
23 |   bigint p02,p12,p0p,p1p,p;
24 | 
25 |   // legacy
26 |   if (dir == "")
27 |     dir = PREP_DIR;
28 | 
29 |   string filename=dir+"/Params-Data";
30 |   
31 |   ifstream inpf(filename.c_str());
32 |   if (inpf.fail()) { throw file_error(filename); }
33 |   inpf >> p;
34 |   inpf >> lg2;
35 |   inpf >> Rp;
36 |   inpf >> FTD;
37 |   inpf >> p0p >> p1p;
38 | 
39 |   if (p != FTD.get_prime())
40 |     throw runtime_error("inconsistent p in Params-Data");
41 | 
42 |   if (!skip_2)
43 |     {
44 |       // initialize before reading P2D for consistency check
45 |       gf2n::init_field(lg2);
46 |       inpf >> R2;
47 |       inpf >> P2D;
48 |       if (R2.phi_m() != P2D.phi_m())
49 |         throw runtime_error("phi(m) mismatch between ring and plaintext representation");
50 |       inpf >> p02 >> p12;
51 |     }
52 | 
53 |   if (inpf.fail())
54 |       throw file_error("incomplete parameters");
55 | 
56 |   inpf.close();
57 | 
58 |   gfp::init_field(FTD.get_prime());
59 |   params_p.set(Rp,{p0p,p1p});
60 |   cout << "log(p) = " << numBits(FTD.get_prime()) << ", log(p0) = "
61 |       << numBits(p0p) << ", " << "log(p1) = " << numBits(p1p) << endl;
62 | 
63 |   if (!skip_2)
64 |     {
65 |       params_2.set(R2,{p02,p12});
66 |       cout << "GF(2^" << lg2 << "): log(p0) = " << numBits(p02)
67 |           << ", log(p1) = " << numBits(p12) << endl;
68 |     }
69 | }
70 | 


--------------------------------------------------------------------------------
/FHEOffline/FullSetup.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef _FullSetup
 4 | #define _FullSetup
 5 | 
 6 | /* Reads in the data created by the setup program */
 7 | 
 8 | #include "FHE/FHE_Params.h"
 9 | #include "FHE/P2Data.h"
10 | #include "Math/Setup.h"
11 | 
12 | void get_setup(FHE_Params& params_p,FFT_Data& FTD,
13 |                FHE_Params& params_2,P2Data& P2D,string dir,
14 |                bool skip_2=false);
15 | 
16 | #endif
17 | 
18 | 
19 | 


--------------------------------------------------------------------------------
/FHEOffline/Multiplier.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * Multiplier.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef FHEOFFLINE_MULTIPLIER_H_
 9 | #define FHEOFFLINE_MULTIPLIER_H_
10 | 
11 | #include "FHEOffline/SimpleEncCommit.h"
12 | #include "FHE/AddableVector.h"
13 | #include "Tools/MemoryUsage.h"
14 | 
15 | template <class FD>
16 | using PlaintextVector = AddableVector< Plaintext_<FD> >;
17 | 
18 | template <class FD>
19 | class PairwiseGenerator;
20 | class PairwiseMachine;
21 | 
22 | template <class FD>
23 | class Multiplier
24 | {
25 |     PairwiseGenerator<FD>& generator;
26 |     PairwiseMachine& machine;
27 |     OffsetPlayer P;
28 |     int num_players, my_num;
29 |     const FHE_PK& other_pk;
30 |     const Ciphertext& other_enc_alpha;
31 |     map<string, Timer>& timers;
32 | 
33 |     // temporary
34 |     Ciphertext C, mask;
35 |     Plaintext_<FD> product_share;
36 |     Random_Coins rc;
37 | 
38 |     size_t volatile_capacity;
39 |     MemoryUsage memory_usage;
40 | 
41 | public:
42 |     Multiplier(int offset, PairwiseGenerator<FD>& generator);
43 |     void multiply_and_add(Plaintext_<FD>& res, const Ciphertext& C,
44 |             const Plaintext_<FD>& b);
45 |     void multiply_and_add(Plaintext_<FD>& res, const Ciphertext& C,
46 |             const Rq_Element& b);
47 |     void multiply_alpha_and_add(Plaintext_<FD>& res, const Rq_Element& b);
48 |     int get_offset() { return P.get_offset(); }
49 |     size_t report_size(ReportType type);
50 |     void report_size(ReportType type, MemoryUsage& res);
51 |     size_t report_volatile() { return volatile_capacity; }
52 | };
53 | 
54 | #endif /* FHEOFFLINE_MULTIPLIER_H_ */
55 | 


--------------------------------------------------------------------------------
/FHEOffline/PairwiseGenerator.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * PairwiseGenerator.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef FHEOFFLINE_PAIRWISEGENERATOR_H_
 9 | #define FHEOFFLINE_PAIRWISEGENERATOR_H_
10 | 
11 | #include <vector>
12 | using namespace std;
13 | 
14 | #include "FHEOffline/Multiplier.h"
15 | #include "FHEOffline/SimpleGenerator.h"
16 | 
17 | class PairwiseMachine;
18 | 
19 | template <class FD>
20 | class PairwiseGenerator : public GeneratorBase
21 | {
22 |     friend MultiEncCommit<FD>;
23 | 
24 |     PlaintextVector<FD> a, b, c;
25 |     AddableVector<Rq_Element> b_mod_q;
26 |     vector<Multiplier<FD>*> multipliers;
27 |     TripleProducer_<FD> producer;
28 |     MultiEncCommit<FD> EC;
29 | 
30 |     // temporary data
31 |     AddableVector<Ciphertext> C;
32 |     octetStream ciphertexts, cleartexts;
33 | 
34 |     size_t volatile_memory;
35 | 
36 | public:
37 |     PairwiseMachine& machine;
38 |     Player global_player;
39 | 
40 |     PairwiseGenerator(int thread_num, PairwiseMachine& machine);
41 |     ~PairwiseGenerator();
42 | 
43 |     void run();
44 |     size_t report_size(ReportType type);
45 |     void report_size(ReportType type, MemoryUsage& res);
46 |     size_t report_sent();
47 | };
48 | 
49 | #endif /* FHEOFFLINE_PAIRWISEGENERATOR_H_ */
50 | 


--------------------------------------------------------------------------------
/FHEOffline/PairwiseMachine.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * PairwiseMachine.cpp
 5 |  *
 6 |  */
 7 | 
 8 | #include "FHEOffline/PairwiseMachine.h"
 9 | #include "Tools/benchmarking.h"
10 | #include "Auth/fake-stuff.h"
11 | 
12 | PairwiseMachine::PairwiseMachine(int argc, const char** argv) :
13 |     MachineBase(argc, argv), P(N, 0xffff << 16),
14 |     other_pks(N.num_players(), {setup_p.params, 0}),
15 |     pk(other_pks[N.my_num()]), sk(pk)
16 | {
17 |     if (use_gf2n)
18 |     {
19 |         field_size = 40;
20 |         gf2n::init_field(field_size);
21 |         setup_keys<P2Data>();
22 |     }
23 |     else
24 |     {
25 |         setup_keys<FFT_Data>();
26 |         bigint p = setup_p.FieldD.get_prime();
27 |         gfp::init_field(p);
28 |         ofstream outf;
29 |         if (output)
30 |             write_online_setup(outf, PREP_DIR, p, 40);
31 |     }
32 | 
33 |     for (int i = 0; i < nthreads; i++)
34 |         if (use_gf2n)
35 |             generators.push_back(new PairwiseGenerator<P2Data>(i, *this));
36 |         else
37 |             generators.push_back(new PairwiseGenerator<FFT_Data>(i, *this));
38 | }
39 | 
40 | template <>
41 | PairwiseSetup<FFT_Data>& PairwiseMachine::setup()
42 | {
43 |     return setup_p;
44 | }
45 | 
46 | template <>
47 | PairwiseSetup<P2Data>& PairwiseMachine::setup()
48 | {
49 |     return setup_2;
50 | }
51 | 
52 | template <class FD>
53 | void PairwiseMachine::setup_keys()
54 | {
55 |     PairwiseSetup<FD>& s = setup<FD>();
56 |     s.init(P, sec, field_size, extra_slack);
57 |     if (output)
58 |         write_mac_keys(PREP_DIR, P.my_num(), P.num_players(), setup_p.alphai,
59 |                 setup_2.alphai);
60 |     for (auto& x : other_pks)
61 |         x = FHE_PK(s.params, s.FieldD.get_prime());
62 |     sk = FHE_SK(pk);
63 |     PRNG G;
64 |     G.ReSeed();
65 |     insecure("local key generation");
66 |     KeyGen(pk, sk, G);
67 |     vector<octetStream> os(N.num_players());
68 |     pk.pack(os[N.my_num()]);
69 |     P.Broadcast_Receive(os);
70 |     for (int i = 0; i < N.num_players(); i++)
71 |         if (i != N.my_num())
72 |             other_pks[i].unpack(os[i]);
73 | 
74 |     insecure("MAC key generation");
75 |     Ciphertext enc_alpha = pk.encrypt(s.alpha);
76 |     os.clear();
77 |     os.resize(N.num_players());
78 |     enc_alphas.resize(N.num_players(), pk);
79 |     enc_alpha.pack(os[N.my_num()]);
80 |     P.Broadcast_Receive(os);
81 |     for (int i = 0; i < N.num_players(); i++)
82 |         if (i != N.my_num())
83 |             enc_alphas[i].unpack(os[i]);
84 |     for (int i = 0; i < N.num_players(); i++)
85 |         cout << "Player " << i << " has pk "
86 |                 << other_pks[i].a().get(0).get_constant().get_limb(0) << " ..."
87 |                 << endl;
88 | }
89 | 
90 | template void PairwiseMachine::setup_keys<FFT_Data>();
91 | template void PairwiseMachine::setup_keys<P2Data>();
92 | 


--------------------------------------------------------------------------------
/FHEOffline/PairwiseMachine.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * PairwiseMachine.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef FHEOFFLINE_PAIRWISEMACHINE_H_
 9 | #define FHEOFFLINE_PAIRWISEMACHINE_H_
10 | 
11 | #include "FHEOffline/PairwiseGenerator.h"
12 | #include "FHEOffline/SimpleMachine.h"
13 | #include "FHEOffline/PairwiseSetup.h"
14 | 
15 | class PairwiseMachine : public MachineBase
16 | {
17 | public:
18 |     PairwiseSetup<FFT_Data> setup_p;
19 |     PairwiseSetup<P2Data> setup_2;
20 |     Player P;
21 | 
22 |     vector<FHE_PK> other_pks;
23 |     FHE_PK& pk;
24 |     FHE_SK sk;
25 |     vector<Ciphertext> enc_alphas;
26 | 
27 |     PairwiseMachine(int argc, const char** argv);
28 | 
29 |     template <class FD>
30 |     void setup_keys();
31 | 
32 |     template <class FD>
33 |     PairwiseSetup<FD>& setup();
34 | };
35 | 
36 | #endif /* FHEOFFLINE_PAIRWISEMACHINE_H_ */
37 | 


--------------------------------------------------------------------------------
/FHEOffline/PairwiseSetup.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * PairwiseSetup.cpp
 5 |  *
 6 |  */
 7 | 
 8 | #include <FHEOffline/PairwiseSetup.h>
 9 | #include "FHE/NoiseBounds.h"
10 | #include "FHE/NTL-Subs.h"
11 | #include "Math/Setup.h"
12 | #include "FHEOffline/Proof.h"
13 | 
14 | template <class FD>
15 | void PairwiseSetup<FD>::init(const Player& P, int sec, int plaintext_length,
16 |     int& extra_slack)
17 | {
18 |     sec = max(sec, 40);
19 |     cout << "Finding parameters for security " << sec << " and field size ~2^"
20 |             << plaintext_length << endl;
21 |     PRNG G;
22 |     G.ReSeed();
23 |     dirname = PREP_DIR;
24 | 
25 |     octetStream o;
26 |     if (P.my_num() == 0)
27 |     {
28 |         extra_slack =
29 |             generate_semi_setup(plaintext_length, sec, params, FieldD, true);
30 |         params.pack(o);
31 |         FieldD.pack(o);
32 |         o.store(extra_slack);
33 |         P.send_all(o);
34 |     }
35 |     else
36 |     {
37 |         P.receive_player(0, o);
38 |         params.unpack(o);
39 |         FieldD.unpack(o);
40 |         FieldD.init_field();
41 |         o.get(extra_slack);
42 |     }
43 | 
44 |     alpha = FieldD;
45 |     alpha.randomize(G, Diagonal);
46 |     alphai = alpha.element(0);
47 | }
48 | 
49 | template class PairwiseSetup<FFT_Data>;
50 | template class PairwiseSetup<P2Data>;
51 | 


--------------------------------------------------------------------------------
/FHEOffline/PairwiseSetup.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * PairwiseSetup.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef FHEOFFLINE_PAIRWISESETUP_H_
 9 | #define FHEOFFLINE_PAIRWISESETUP_H_
10 | 
11 | #include "FHE/FHE_Params.h"
12 | #include "FHE/Plaintext.h"
13 | #include "Networking/Player.h"
14 | 
15 | template <class FD>
16 | class PairwiseSetup
17 | {
18 | public:
19 |     FHE_Params params;
20 |     FD FieldD;
21 |     typename FD::T alphai;
22 |     Plaintext_<FD> alpha;
23 |     string dirname;
24 | 
25 |     PairwiseSetup() : params(0), alpha(FieldD) {}
26 |    
27 |     void init(const Player& P, int sec, int plaintext_length, int& extra_slack);
28 | };
29 | 
30 | #endif /* FHEOFFLINE_PAIRWISESETUP_H_ */
31 | 


--------------------------------------------------------------------------------
/FHEOffline/Player-Offline.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * Player-Offline.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef FHEOFFLINE_PLAYER_OFFLINE_H_
 9 | #define FHEOFFLINE_PLAYER_OFFLINE_H_
10 | 
11 | class thread_info
12 | {
13 |   public:
14 | 
15 |   int thread_num;
16 |   int covert;
17 |   Names*  Nms;
18 |   FHE_PK* pk_p;
19 |   FHE_PK* pk_2;
20 |   FHE_SK* sk_p;
21 |   FHE_SK* sk_2;
22 |   Ciphertext *calphap;
23 |   Ciphertext *calpha2;
24 |   gfp *alphapi;
25 |   gf2n_short *alpha2i;
26 | 
27 |   FFT_Data *FTD;
28 |   P2Data *P2D;
29 | 
30 |   int nm2,nmp,nb2,nbp,ni2,nip,ns2,nsp,nvp;
31 |   bool skip_2() { return nm2 + ni2 + nb2 + ns2 == 0; }
32 | };
33 | 
34 | #endif /* FHEOFFLINE_PLAYER_OFFLINE_H_ */
35 | 


--------------------------------------------------------------------------------
/FHEOffline/Prover.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef _Prover
 4 | #define _Prover
 5 | 
 6 | #include "Proof.h"
 7 | #include "Tools/MemoryUsage.h"
 8 | 
 9 | /* Class for the prover */
10 | 
11 | template<class FD, class U>
12 | class Prover
13 | {
14 |   /* Provers state */
15 |   Proof::Randomness s;
16 |   AddableVector< Plaintext_<FD> > y;
17 | 
18 | #ifdef LESS_ALLOC_MORE_MEM
19 |   AddableVector<bigint> z;
20 |   AddableMatrix<bigint> t;
21 | #endif
22 | 
23 | public:
24 |   size_t volatile_memory;
25 | 
26 |   Prover(Proof& proof, const FD& FieldD);
27 | 
28 |   void Stage_1(const Proof& P, octetStream& ciphertexts, const AddableVector<Ciphertext>& c,
29 |       const FHE_PK& pk, bool Diag,
30 |       bool binary = false);
31 | 
32 |   bool Stage_2(Proof& P, octetStream& cleartexts,
33 |                const vector<U>& x,
34 |                const Proof::Randomness& r,
35 |                const vector<int>& e);
36 | 
37 |   /* Only has a non-interactive version using the ROM 
38 |       - If Diag is true then the plaintexts x are assumed to be
39 |         diagonal elements, i.e. x=(x_1,x_1,...,x_1)
40 |   */
41 |   size_t NIZKPoK(Proof& P, octetStream& ciphertexts, octetStream& cleartexts,
42 | 	       const FHE_PK& pk,
43 |                const AddableVector<Ciphertext>& c,
44 |                const vector<U>& x,
45 |                const Proof::Randomness& r,
46 |                bool Diag,bool binary=false);
47 | 
48 |   size_t report_size(ReportType type);
49 |   void report_size(ReportType type, MemoryUsage& res);
50 | };
51 | 
52 | #endif
53 | 


--------------------------------------------------------------------------------
/FHEOffline/Reshare.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | 
 4 | #include "FHEOffline/Reshare.h"
 5 | #include "FHEOffline/DistDecrypt.h"
 6 | #include "Tools/random.h"
 7 | 
 8 | template<class T,class FD,class S>
 9 | void Reshare(Plaintext<T,FD,S>& m,Ciphertext& cc,
10 |              const Ciphertext& cm,bool NewCiphertext,
11 |              const Player& P,EncCommitBase<T,FD,S>& EC,
12 |              const FHE_PK& pk,const FHE_SK& share)
13 | {
14 |   DistDecrypt<FD> dd(P, share, pk, m.get_field());
15 |   Reshare(m, cc, cm, NewCiphertext, P, EC, pk, dd);
16 | }
17 | 
18 | template<class T,class FD,class S>
19 | void Reshare(Plaintext<T,FD,S>& m,Ciphertext& cc,
20 |              const Ciphertext& cm,bool NewCiphertext,
21 |              const Player& P,EncCommitBase<T,FD,S>& EC,
22 |              const FHE_PK& pk,DistDecrypt<FD>& dd)
23 | {
24 |   const FHE_Params& params=pk.get_params();
25 | 
26 |   // Step 1
27 |   Ciphertext cf(params);
28 |   Plaintext_<FD>& f = dd.f;
29 |   EC.next(f,cf);
30 | 
31 |   // Step 2
32 |   // We could be resharing a level 0 ciphertext so adjust if we are
33 |   if (cm.level()==0) { cf.Scale(m.get_field().get_prime()); }
34 |   Ciphertext cmf(params);
35 |   add(cmf,cf,cm);
36 | 
37 |   // Step 3
38 |   Plaintext_<FD>& mf = dd.mf;
39 |   dd.run(cmf, NewCiphertext);
40 |   
41 |   // Step 4
42 |   if (P.my_num()==0)
43 |     { sub(m,mf,f); }
44 |   else
45 |     { m=f; m.negate(); }
46 |  
47 |   // Step 5
48 |   if (NewCiphertext)
49 |     { unsigned char sd[SEED_SIZE] = { 0 };
50 |       PRNG G;
51 |       G.SetSeed(sd);
52 |       Random_Coins rc(params);
53 |       rc.generate(G);
54 |       pk.encrypt(cc,mf,rc);
55 |       // And again
56 |       if (cf.level()==0) { cc.Scale(m.get_field().get_prime()); }
57 |       sub(cc,cc,cf);
58 |     }
59 | }
60 | 
61 | 
62 | 
63 | 
64 | template void Reshare(Plaintext<gfp,FFT_Data,bigint>& m,Ciphertext& cc,
65 |                       const Ciphertext& cm,bool NewCiphertext,
66 |                       const Player& P,EncCommitBase<gfp,FFT_Data,bigint>& EC,
67 |                       const FHE_PK& pk,DistDecrypt<FFT_Data>& dd);
68 | 
69 | template void Reshare(Plaintext<gf2n_short,P2Data,int>& m,Ciphertext& cc,
70 |                       const Ciphertext& cm,bool NewCiphertext,
71 |                       const Player& P,EncCommitBase<gf2n_short,P2Data,int>& EC,
72 |                       const FHE_PK& pk,DistDecrypt<P2Data>& dd);
73 | 
74 | 
75 | template void Reshare(Plaintext<gfp,FFT_Data,bigint>& m,Ciphertext& cc,
76 |                       const Ciphertext& cm,bool NewCiphertext,
77 |                       const Player& P,EncCommitBase<gfp,FFT_Data,bigint>& EC,
78 |                       const FHE_PK& pk,const FHE_SK& share);
79 | 
80 | template void Reshare(Plaintext<gf2n_short,P2Data,int>& m,Ciphertext& cc,
81 |                       const Ciphertext& cm,bool NewCiphertext,
82 |                       const Player& P,EncCommitBase<gf2n_short,P2Data,int>& EC,
83 |                       const FHE_PK& pk,const FHE_SK& share);
84 | 
85 | 
86 | 


--------------------------------------------------------------------------------
/FHEOffline/Reshare.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef _Reshare
 4 | #define _Reshare
 5 | 
 6 | /* The procedure for the Reshare protocol 
 7 |  *   Input is a ciphertext cm and a flag NewCiphertext
 8 |  *   Output is a Ring_Element and possibly a ciphertext cc
 9 |  */
10 | 
11 | #include "FHE/Ciphertext.h"
12 | #include "Networking/Player.h"
13 | #include "FHEOffline/EncCommit.h"
14 | 
15 | template <class FD> class DistDecrypt;
16 | 
17 | template<class T,class FD,class S>
18 | void Reshare(Plaintext<T,FD,S>& m,Ciphertext& cc,
19 |              const Ciphertext& cm,bool NewCiphertext,
20 |              const Player& P,EncCommitBase<T,FD,S>& EC,
21 |              const FHE_PK& pk,const FHE_SK& share);
22 | 
23 | template<class T,class FD,class S>
24 | void Reshare(Plaintext<T,FD,S>& m,Ciphertext& cc,
25 |              const Ciphertext& cm,bool NewCiphertext,
26 |              const Player& P,EncCommitBase<T,FD,S>& EC,
27 |              const FHE_PK& pk,DistDecrypt<FD>& dd);
28 | 
29 | #endif
30 | 
31 | 


--------------------------------------------------------------------------------
/FHEOffline/Sacrificing.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * Checking.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef FHEOFFLINE_CHECKING_H_
 9 | #define FHEOFFLINE_CHECKING_H_
10 | 
11 | #include "Networking/Player.h"
12 | #include "Auth/MAC_Check.h"
13 | #include "Math/Setup.h"
14 | 
15 | template <class T>
16 | class TripleSacriFactory
17 | {
18 | public:
19 |     virtual ~TripleSacriFactory() {}
20 |     virtual void get(T& a, T& b, T& c) = 0;
21 | };
22 | 
23 | template <class T>
24 | class TupleSacriFactory
25 | {
26 | public:
27 |     virtual ~TupleSacriFactory() {}
28 |     virtual void get(T& a, T& b) = 0;
29 | };
30 | 
31 | template <class T>
32 | class SingleSacriFactory
33 | {
34 | public:
35 |     virtual ~SingleSacriFactory() {}
36 |     virtual void get(T& a) = 0;
37 | };
38 | 
39 | template <class T>
40 | class FileSacriFactory : public TripleSacriFactory<T>,
41 |         public TupleSacriFactory<T>, public SingleSacriFactory<T>
42 | {
43 |     ifstream inpf;
44 | 
45 | public:
46 |     FileSacriFactory(const char* type, const Player& P, int output_thread);
47 |     void get(T& a, T& b, T& c);
48 |     void get(T& a, T& b);
49 |     void get(T& a);
50 | };
51 | 
52 | void Triple_Inverse_Checking(const Player& P, MAC_Check<gfp>& MC, int nm,
53 |     int nr, int output_thread = 0);
54 | template <class T>
55 | void Triple_Checking(const Player& P, MAC_Check<T>& MC, int nm,
56 |         int output_thread, TripleSacriFactory<Share<T> >& factory,
57 |         bool write_output = true, bool clear = true, string dir = PREP_DIR);
58 | template <class T>
59 | void Inverse_Checking(const Player& P, MAC_Check<T>& MC, int nr,
60 |         int output_thread, TripleSacriFactory<Share<T> >& triple_factory,
61 |         TupleSacriFactory<Share<T> >& inverse_factor,
62 |         bool write_output = true, bool clear = true, string dir = PREP_DIR);
63 | void Triple_Checking(const Player& P,MAC_Check<gf2n_short>& MC,int nm);
64 | void Square_Bit_Checking(const Player& P,MAC_Check<gfp>& MC,int ns,int nb);
65 | template <class T>
66 | void Square_Checking(const Player& P, MAC_Check<T>& MC, int ns,
67 |         int output_thread, TupleSacriFactory<Share<T> >& factory,
68 |         bool write_output = true, bool clear = true, string dir = PREP_DIR);
69 | void Bit_Checking(const Player& P, MAC_Check<gfp>& MC, int nb,
70 |         int output_thread, TupleSacriFactory<Share<gfp> >& square_factory,
71 |         SingleSacriFactory<Share<gfp> >& bit_factory, bool write_output = true,
72 |         bool clear = true, string dir = PREP_DIR);
73 | void Square_Checking(const Player& P,MAC_Check<gf2n_short>& MC,int ns);
74 | 
75 | template <class T>
76 | inline string file_completion(const T& dummy = {})
77 | {
78 |   (void)dummy;
79 |   return { T::type_char() };
80 | }
81 | 
82 | #endif /* FHEOFFLINE_CHECKING_H_ */
83 | 


--------------------------------------------------------------------------------
/FHEOffline/SimpleDistDecrypt.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * SimpleDistDecrypt.cpp
 5 |  *
 6 |  */
 7 | 
 8 | #include <FHEOffline/SimpleDistDecrypt.h>
 9 | 
10 | template <class FD>
11 | void SimpleDistDecrypt<FD>::intermediate_step()
12 | {
13 |     for (unsigned int i = 0; i < this->vv.size(); i++)
14 |         this->vv[i] += this->f.coeff(i);
15 | }
16 | 
17 | template <class FD>
18 | void SimpleDistDecrypt<FD>::reshare(Plaintext<typename FD::T, FD, typename FD::S>& m,
19 |         const Ciphertext& cm,
20 |         EncCommitBase<typename FD::T, FD, typename FD::S>& EC)
21 | {
22 |     (void)EC;
23 | 
24 |     PRNG G;
25 |     G.ReSeed();
26 |     this->f.randomize(G, Full);
27 | 
28 |     // Step 3
29 |     this->run(cm);
30 | 
31 |     // Step 4
32 |     if (this->P.my_num()==0)
33 |       { sub(m,this->mf,this->f); }
34 |     else
35 |       { m=this->f; m.negate(); }
36 | }
37 | 
38 | 
39 | template class SimpleDistDecrypt<FFT_Data>;
40 | template class SimpleDistDecrypt<P2Data>;
41 | 


--------------------------------------------------------------------------------
/FHEOffline/SimpleDistDecrypt.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * SimpleDistDecrypt.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef FHEOFFLINE_SIMPLEDISTDECRYPT_H_
 9 | #define FHEOFFLINE_SIMPLEDISTDECRYPT_H_
10 | 
11 | #include "FHEOffline/DistDecrypt.h"
12 | #include "FHEOffline/DataSetup.h"
13 | 
14 | template <class FD>
15 | class SimpleDistDecrypt : public DistDecrypt<FD>
16 | {
17 | public:
18 |     SimpleDistDecrypt(const Player& P, const PartSetup<FD>& setup) :
19 |             DistDecrypt<FD>(P, setup.sk, setup.pk, setup.FieldD) {}
20 | 
21 |     void intermediate_step();
22 |     void reshare(Plaintext<typename FD::T, FD, typename FD::S>& m,
23 |         const Ciphertext& cm,
24 |         EncCommitBase<typename FD::T, FD, typename FD::S>& EC);
25 | };
26 | 
27 | #endif /* FHEOFFLINE_SIMPLEDISTDECRYPT_H_ */
28 | 


--------------------------------------------------------------------------------
/FHEOffline/SimpleGenerator.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * SimpleThread.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef FHEOFFLINE_SIMPLEGENERATOR_H_
 9 | #define FHEOFFLINE_SIMPLEGENERATOR_H_
10 | 
11 | #include "Networking/Player.h"
12 | #include "FHEOffline/SimpleEncCommit.h"
13 | #include "FHEOffline/DataSetup.h"
14 | #include "FHEOffline/Producer.h"
15 | #include "FHEOffline/SimpleDistDecrypt.h"
16 | #include "Processor/Data_Files.h"
17 | 
18 | class SimpleMachine;
19 | class MultiplicativeMachine;
20 | 
21 | class GeneratorBase
22 | {
23 | protected:
24 |     int thread_num;
25 | 
26 | public:
27 |     Player P;
28 |     pthread_t thread;
29 |     long long total;
30 | 
31 |     map<string, Timer> timers;
32 | 
33 |     GeneratorBase(int thread_num, const Names& N) :
34 |         thread_num(thread_num), P(N, thread_num << 16), thread(0), total(0) {}
35 |     virtual ~GeneratorBase() {}
36 |     virtual void run() = 0;
37 |     virtual size_t report_size(ReportType type) = 0;
38 |     virtual void report_size(ReportType type, MemoryUsage& res) = 0;
39 |     virtual size_t report_sent() = 0;
40 | 
41 |     int get_thread_num() const { return thread_num; }
42 | };
43 | 
44 | template <template <class FD> class T, class FD>
45 | class SimpleGenerator : public GeneratorBase
46 | {
47 |     const PartSetup<FD>& setup;
48 |     const MultiplicativeMachine& machine;
49 | 
50 |     SimpleDistDecrypt<FD> dd;
51 | 
52 |     size_t volatile_memory;
53 | 
54 | public:
55 |     T<FD> EC;
56 |     Producer<FD>* producer;
57 | 
58 |     SimpleGenerator(const Names& N, const PartSetup<FD>& setup,
59 |             const MultiplicativeMachine& machine, int thread_num,
60 |             Dtype data_type = DATA_TRIPLE);
61 |     ~SimpleGenerator();
62 | 
63 |     void run();
64 |     size_t report_size(ReportType type);
65 |     void report_size(ReportType type, MemoryUsage& res);
66 |     size_t report_sent() { return P.sent; }
67 | };
68 | 
69 | #endif /* FHEOFFLINE_SIMPLEGENERATOR_H_ */
70 | 


--------------------------------------------------------------------------------
/FHEOffline/SimpleMachine.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * SimpleMachine.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef FHEOFFLINE_SIMPLEMACHINE_H_
 9 | #define FHEOFFLINE_SIMPLEMACHINE_H_
10 | 
11 | #include "FHE/FHE_Keys.h"
12 | #include "FHEOffline/DataSetup.h"
13 | #include "Networking/Player.h"
14 | #include "FHEOffline/SimpleGenerator.h"
15 | #include "Tools/OfflineMachineBase.h"
16 | 
17 | class MachineBase : public OfflineMachineBase
18 | {
19 | protected:
20 |     vector<GeneratorBase*> generators;
21 |     string hostname;
22 |     Timer timer;
23 |     pthread_t throughput_loop_thread;
24 |     int portnum_base;
25 |     Dtype data_type;
26 | 
27 | public:
28 |     int sec;
29 |     int field_size;
30 |     int extra_slack;
31 |     bool produce_inputs;
32 |     bool use_gf2n;
33 | 
34 |     MachineBase();
35 |     MachineBase(int argc, const char** argv);
36 |     void run();
37 | 
38 |     void parse_options(int argc, const char** argv);
39 | 
40 |     string item_type();
41 | 
42 |     void throughput_loop();
43 |     static void* run_throughput_loop(void* machine);
44 | 
45 |     size_t report_size(ReportType type);
46 | 
47 |     string tradeoff();
48 | 
49 |     void mult_performance();
50 | };
51 | 
52 | class MultiplicativeMachine : public MachineBase
53 | {
54 | protected:
55 |     DataSetup setup;
56 | 
57 |     void parse_options(int argc, const char** argv);
58 | 
59 |     void generate_setup(int slack);
60 |     template <class FD>
61 |     void fake_keys(int slack);
62 | 
63 | public:
64 |     virtual ~MultiplicativeMachine() {}
65 | 
66 |     virtual int get_covert() const { return 0; }
67 | };
68 | 
69 | class SimpleMachine : public MultiplicativeMachine
70 | {
71 |     template <template <class FD> class EC, class FD>
72 |     GeneratorBase* new_generator(int i);
73 | 
74 | public:
75 |     SimpleMachine(int argc, const char** argv);
76 | };
77 | 
78 | #endif /* FHEOFFLINE_SIMPLEMACHINE_H_ */
79 | 


--------------------------------------------------------------------------------
/FHEOffline/Verifier.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef _Verifier
 4 | #define _Verifier
 5 | 
 6 | #include "Proof.h"
 7 | 
 8 | /* Defines the Verifier */
 9 | template <class FD, class S>
10 | class Verifier
11 | {
12 |   AddableVector<S> z;
13 |   AddableMatrix<S> t;
14 | 
15 |   const Proof& P;
16 | 
17 | public:
18 |   Verifier(const Proof& proof);
19 | 
20 |   void Stage_2(const vector<int>& e,
21 |       AddableVector<Ciphertext>& c, octetStream& ciphertexts,
22 |       octetStream& cleartexts,const FHE_PK& pk,bool Diag,bool binary=false);
23 | 
24 |   /* This is the non-interactive version using the ROM
25 |       - Creates space for all output values
26 |       - Diag flag mirrors that in Prover
27 |   */
28 |   void NIZKPoK(AddableVector<Ciphertext>& c,octetStream& ciphertexts,octetStream& cleartexts,
29 |                const FHE_PK& pk,bool Diag,bool binary=false);
30 | 
31 |   size_t report_size(ReportType type) { return z.report_size(type) + t.report_size(type); }
32 | };
33 | 
34 | #endif
35 | 


--------------------------------------------------------------------------------
/FHEOffline/config.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * config.h
 3 |  *
 4 |  *  Created on: 2 Oct. 2018
 5 |  *      Author: kel323
 6 |  */
 7 | 
 8 | #ifndef FHEOFFLINE_CONFIG_H_
 9 | #define FHEOFFLINE_CONFIG_H_
10 | 
11 | #ifndef LESS_MEM_MORE_ALLOC
12 | #define LESS_ALLOC_MORE_MEM
13 | #endif
14 | 
15 | #endif /* FHEOFFLINE_CONFIG_H_ */
16 | 


--------------------------------------------------------------------------------
/HOSTS.example:
--------------------------------------------------------------------------------
1 | 192.168.0.1
2 | 192.168.0.2
3 | 192.168.0.3
4 | 192.168.0.4
5 | 192.168.0.5
6 | 


--------------------------------------------------------------------------------
/License.txt:
--------------------------------------------------------------------------------
 1 | University of Bristol : Open Access Software Licence
 2 | 
 3 | Copyright (c) 2018, The University of Bristol, a chartered corporation having Royal Charter number RC000648 and a charity (number X1121) and its place of administration being at Senate House, Tyndall Avenue, Bristol, BS8 1TH, United Kingdom.
 4 | 
 5 | All rights reserved
 6 | 
 7 | Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
 8 | 
 9 | 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
10 | 
11 | 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
12 | 
13 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
14 | 
15 | 
16 | Any use of the software for scientific publications or commercial purposes should be reported to the University of Bristol (OSI-notifications@bristol.ac.uk and quote reference 1914). This is for impact and usage monitoring purposes only.
17 | 
18 | Enquiries about further applications and development opportunities are welcome. Please contact nigel@cs.bris.ac.uk
19 | 
20 | 


--------------------------------------------------------------------------------
/Math/Integer.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * Integer.cpp
 5 |  *
 6 |  */
 7 | 
 8 | #include "Integer.h"
 9 | 
10 | void Integer::output(ostream& s,bool human) const
11 | {
12 |   if (human)
13 |     s << a;
14 |   else
15 |     s.write((char*)&a, sizeof(a));
16 | }
17 | 
18 | void Integer::input(istream& s,bool human)
19 | {
20 |   if (human)
21 |     s >> a;
22 |   else
23 |     s.read((char*)&a, sizeof(a));
24 | }
25 | 


--------------------------------------------------------------------------------
/Math/Integer.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * Integer.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef INTEGER_H_
 9 | #define INTEGER_H_
10 | 
11 | #include <iostream>
12 | using namespace std;
13 | 
14 | // Wrapper class for integer, used for Memory
15 | 
16 | class Integer
17 | {
18 | protected:
19 |   long a;
20 | 
21 |   public:
22 | 
23 |   static string type_string() { return "integer"; }
24 | 
25 |   Integer()                 { a = 0; }
26 |   Integer(long a) : a(a)    {}
27 | 
28 |   long get() const          { return a; }
29 | 
30 |   void assign_zero()        { a = 0; }
31 | 
32 |   long operator+(const Integer& other) const { return a + other.a; }
33 |   long operator-(const Integer& other) const { return a - other.a; }
34 |   long operator*(const Integer& other) const { return a * other.a; }
35 |   long operator/(const Integer& other) const { return a / other.a; }
36 | 
37 |   long operator>>(const Integer& other) const { return a >> other.a; }
38 |   long operator<<(const Integer& other) const { return a << other.a; }
39 | 
40 |   long operator^(const Integer& other) const { return a ^ other.a; }
41 |   long operator&(const Integer& other) const { return a ^ other.a; }
42 |   long operator|(const Integer& other) const { return a ^ other.a; }
43 | 
44 |   bool operator==(const Integer& other) const { return a == other.a; }
45 |   bool operator!=(const Integer& other) const { return a != other.a; }
46 |   bool operator<(const Integer& other) const { return a < other.a; }
47 |   bool operator<=(const Integer& other) const { return a <= other.a; }
48 |   bool operator>(const Integer& other) const { return a > other.a; }
49 |   bool operator>=(const Integer& other) const { return a >= other.a; }
50 | 
51 |   long operator^=(const Integer& other) { return a ^= other.a; }
52 | 
53 |   friend unsigned int& operator+=(unsigned int& x, const Integer& other) { return x += other.a; }
54 | 
55 |   friend ostream& operator<<(ostream& s, const Integer& x) { x.output(s, true); return s; }
56 | 
57 |   void output(ostream& s,bool human) const;
58 |   void input(istream& s,bool human);
59 | 
60 | };
61 | 
62 | #endif /* INTEGER_H_ */
63 | 


--------------------------------------------------------------------------------
/Math/Setup.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * Setup.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef MATH_SETUP_H_
 9 | #define MATH_SETUP_H_
10 | 
11 | #include "Math/bigint.h"
12 | 
13 | #include <iostream>
14 | using namespace std;
15 | 
16 | #ifndef PREP_DIR
17 | #define PREP_DIR "Player-Data/"
18 | #endif
19 | 
20 | /*
21 |  * Routines to create and read setup files for the finite fields
22 |  */
23 | 
24 | // Create setup file for gfp and gf2n
25 | void generate_online_setup(ofstream& outf, string dirname, bigint& p, int lgp, int lg2);
26 | void write_online_setup(ofstream& outf, string dirname, const bigint& p, int lg2);
27 | 
28 | // Setup primes only
29 | // Chooses a p of at least lgp bits
30 | void SPDZ_Data_Setup_Primes(bigint& p,int lgp,int& idx,int& m);
31 | void generate_prime(bigint& p, int lgp, int m);
32 | 
33 | // get main directory for prep. data
34 | string get_prep_dir(int nparties, int lg2p, int gf2ndegree);
35 | 
36 | // Read online setup file for gfp and gf2n
37 | void read_setup(const string& dir_prefix);
38 | void read_setup(int nparties, int lg2p, int gf2ndegree);
39 | 
40 | 
41 | #endif /* MATH_SETUP_H_ */
42 | 


--------------------------------------------------------------------------------
/Math/Share.cpp:
--------------------------------------------------------------------------------
  1 | // (C) 2018 University of Bristol. See License.txt
  2 | 
  3 | 
  4 | #include "Share.h"
  5 | //#include "Tools/random.h"
  6 | #include "Math/gfp.h"
  7 | #include "Math/gf2n.h"
  8 | #include "Math/operators.h"
  9 | 
 10 | 
 11 | template<class T>
 12 | Share<T>::Share(const T& aa, int my_num, const T& alphai)
 13 | {
 14 |     if (my_num == 0)
 15 |         a = aa;
 16 |     else
 17 |         a.assign_zero();
 18 |     mac = aa * alphai;
 19 | }
 20 | 
 21 | 
 22 | template<class T>
 23 | void Share<T>::mul_by_bit(const Share<T>& S,const T& aa)
 24 | {
 25 |   a.mul(S.a,aa);
 26 |   mac.mul(S.mac,aa);
 27 | }
 28 | 
 29 | template<>
 30 | void Share<gf2n>::mul_by_bit(const Share<gf2n>& S, const gf2n& aa)
 31 | {
 32 |   a.mul_by_bit(S.a,aa);
 33 |   mac.mul_by_bit(S.mac,aa);
 34 | }
 35 | 
 36 | template<class T>
 37 | void Share<T>::add(const Share<T>& S,const T& aa,bool playerone,const T& alphai)
 38 | {
 39 |   if (playerone) 
 40 |      { a.add(S.a,aa); }
 41 |   else           
 42 |      { a=S.a;   }
 43 | 
 44 |   T tmp;
 45 |   tmp.mul(alphai,aa);
 46 |   mac.add(S.mac,tmp);
 47 | }
 48 | 
 49 | 
 50 | 
 51 | template<class T>
 52 | void Share<T>::sub(const Share<T>& S,const T& aa,bool playerone,const T& alphai)
 53 | {
 54 |   if (playerone) 
 55 |     { a.sub(S.a,aa); }
 56 |   else           
 57 |     { a=S.a;   }
 58 | 
 59 |   T tmp;
 60 |   tmp.mul(alphai,aa);
 61 |   mac.sub(S.mac,tmp);
 62 | }
 63 | 
 64 | 
 65 | 
 66 | template<class T>
 67 | void Share<T>::sub(const T& aa,const Share<T>& S,bool playerone,const T& alphai)
 68 | {
 69 |   if (playerone) 
 70 |     { a.sub(aa,S.a); }
 71 |   else           
 72 |     { a=S.a;
 73 |       a.negate(); 
 74 |     }
 75 | 
 76 |   T tmp;
 77 |   tmp.mul(alphai,aa);
 78 |   mac.sub(tmp,S.mac);
 79 | }
 80 | 
 81 | 
 82 | 
 83 | template<class T>
 84 | void Share<T>::sub(const Share<T>& S1,const Share<T>& S2)
 85 | {
 86 |   a.sub(S1.a,S2.a);
 87 |   mac.sub(S1.mac,S2.mac);
 88 | }
 89 | 
 90 | 
 91 | 
 92 | template<class T>
 93 | T combine(const vector< Share<T> >& S)
 94 | {
 95 |   T ans=S[0].a;
 96 |   for (unsigned int i=1; i<S.size(); i++) 
 97 |     { ans.add(ans,S[i].a); }
 98 |   return ans;
 99 | }
100 | 
101 | 
102 | 
103 | 
104 | template<class T>
105 | inline void Share<T>::pack(octetStream& os) const
106 | {
107 |   a.pack(os);
108 |   mac.pack(os);
109 | }
110 | 
111 | template<class T>
112 | inline void Share<T>::unpack(octetStream& os)
113 | {
114 |   a.unpack(os);
115 |   mac.unpack(os);
116 | }
117 | 
118 | 
119 | template<class T>
120 | bool check_macs(const vector< Share<T> >& S,const T& key)
121 | {
122 |   T val=combine(S);
123 | 
124 |   // Now check the MAC is valid
125 |   val.mul(val,key);
126 |   for (unsigned i=0; i<S.size(); i++)
127 |     { val.sub(val,S[i].mac); }
128 |   if (!val.is_zero()) { return false; }
129 |   return true;
130 | }
131 | 
132 | template class Share<gf2n>;
133 | template class Share<gfp>;
134 | template gf2n combine(const vector< Share<gf2n> >& S);
135 | template gfp combine(const vector< Share<gfp> >& S);
136 | template bool check_macs(const vector< Share<gf2n> >& S,const gf2n& key);
137 | template bool check_macs(const vector< Share<gfp> >& S,const gfp& key);
138 | 
139 | #ifdef USE_GF2N_LONG
140 | template class Share<gf2n_short>;
141 | template gf2n_short combine(const vector< Share<gf2n_short> >& S);
142 | template bool check_macs(const vector< Share<gf2n_short> >& S,const gf2n_short& key);
143 | #endif
144 | 


--------------------------------------------------------------------------------
/Math/Subroutines.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef _Subroutines
 4 | #define _Subroutines
 5 | 
 6 | 
 7 | #include "Math/Zp_Data.h"
 8 | 
 9 | void Subs(modp& ans,const vector<int>& poly,const modp& x,const Zp_Data& ZpD);
10 | 
11 | 
12 | /* Find an m'th primitive root moduli the current prime
13 |  *   This is deterministic so all players have the same root of unity
14 |  *   poly is Phi_m(X)
15 |  */
16 | modp Find_Primitive_Root_m(int m,const vector<int>& poly,const Zp_Data& ZpD);
17 | 
18 | 
19 | /* Find a (2m)'th primitive root moduli the current prime
20 |  *   This is deterministic so all players have the same root of unity
21 |  *   poly is Phi_m(X)
22 |  */
23 | modp Find_Primitive_Root_2m(int m,const vector<int>& poly,const Zp_Data& ZpD);
24 | 
25 | 
26 | /* Find an mth primitive root moduli the current prime
27 |  *   This is deterministic so all players have the same root of unity
28 |  * This assumes m is a power of two and so the cyclotomic polynomial
29 |  * is  F=X^{m/2}+1
30 |  */
31 | modp Find_Primitive_Root_2power(int m,const Zp_Data& ZpD);
32 | 
33 | #endif
34 | 


--------------------------------------------------------------------------------
/Math/field_types.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * types.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef MATH_FIELD_TYPES_H_
 9 | #define MATH_FIELD_TYPES_H_
10 | 
11 | 
12 | enum DataFieldType { DATA_MODP, DATA_GF2N, N_DATA_FIELD_TYPE };
13 | 
14 | 
15 | #endif /* MATH_FIELD_TYPES_H_ */
16 | 


--------------------------------------------------------------------------------
/Math/gfp.cpp:
--------------------------------------------------------------------------------
  1 | // (C) 2018 University of Bristol. See License.txt
  2 | 
  3 | 
  4 | #include "Math/gfp.h"
  5 | 
  6 | #include "Exceptions/Exceptions.h"
  7 | 
  8 | Zp_Data gfp::ZpD;
  9 | 
 10 | void gfp::almost_randomize(PRNG& G)
 11 | {
 12 |   G.get_octets((octet*)a.x,t()*sizeof(mp_limb_t));
 13 |   a.x[t()-1]&=ZpD.mask;
 14 | }
 15 | 
 16 | void gfp::AND(const gfp& x,const gfp& y)
 17 | {
 18 |   bigint bi1,bi2;
 19 |   to_bigint(bi1,x);
 20 |   to_bigint(bi2,y);
 21 |   mpz_and(bi1.get_mpz_t(), bi1.get_mpz_t(), bi2.get_mpz_t());
 22 |   to_gfp(*this, bi1);
 23 | }
 24 | 
 25 | void gfp::OR(const gfp& x,const gfp& y)
 26 | {
 27 |   bigint bi1,bi2;
 28 |   to_bigint(bi1,x);
 29 |   to_bigint(bi2,y);
 30 |   mpz_ior(bi1.get_mpz_t(), bi1.get_mpz_t(), bi2.get_mpz_t());
 31 |   to_gfp(*this, bi1);
 32 | }
 33 | 
 34 | void gfp::XOR(const gfp& x,const gfp& y)
 35 | {
 36 |   bigint bi1,bi2;
 37 |   to_bigint(bi1,x);
 38 |   to_bigint(bi2,y);
 39 |   mpz_xor(bi1.get_mpz_t(), bi1.get_mpz_t(), bi2.get_mpz_t());
 40 |   to_gfp(*this, bi1);
 41 | }
 42 | 
 43 | void gfp::AND(const gfp& x,const bigint& y)
 44 | {
 45 |   bigint bi;
 46 |   to_bigint(bi,x);
 47 |   mpz_and(bi.get_mpz_t(), bi.get_mpz_t(), y.get_mpz_t());
 48 |   to_gfp(*this, bi);
 49 | }
 50 | 
 51 | void gfp::OR(const gfp& x,const bigint& y)
 52 | {
 53 |   bigint bi;
 54 |   to_bigint(bi,x);
 55 |   mpz_ior(bi.get_mpz_t(), bi.get_mpz_t(), y.get_mpz_t());
 56 |   to_gfp(*this, bi);
 57 | }
 58 | 
 59 | void gfp::XOR(const gfp& x,const bigint& y)
 60 | {
 61 |   bigint bi;
 62 |   to_bigint(bi,x);
 63 |   mpz_xor(bi.get_mpz_t(), bi.get_mpz_t(), y.get_mpz_t());
 64 |   to_gfp(*this, bi);
 65 | }
 66 | 
 67 | 
 68 | 
 69 | 
 70 | void gfp::SHL(const gfp& x,int n)
 71 | {
 72 |   if (!x.is_zero())
 73 |     {
 74 |       if (n != 0)
 75 |         {
 76 |           bigint bi;
 77 |           to_bigint(bi,x,false);
 78 |           mpn_lshift(bi.get_mpz_t()->_mp_d, bi.get_mpz_t()->_mp_d, bi.get_mpz_t()->_mp_size,n);
 79 |           to_gfp(*this, bi);
 80 |         }
 81 |       else
 82 |         assign(x);
 83 |     }
 84 |   else
 85 |     {
 86 |       assign_zero();
 87 |     }
 88 | }
 89 | 
 90 | 
 91 | void gfp::SHR(const gfp& x,int n)
 92 | {
 93 |   if (!x.is_zero())
 94 |     {
 95 |       if (n != 0)
 96 |         {
 97 |           bigint bi;
 98 |           to_bigint(bi,x);
 99 |           mpn_rshift(bi.get_mpz_t()->_mp_d, bi.get_mpz_t()->_mp_d, bi.get_mpz_t()->_mp_size,n);
100 |           to_gfp(*this, bi);
101 |         }
102 |       else
103 |         assign(x);
104 |     }
105 |   else
106 |     {
107 |       assign_zero();
108 |     }
109 | }
110 | 
111 | 
112 | void gfp::SHL(const gfp& x,const bigint& n)
113 | {
114 |   SHL(x,mpz_get_si(n.get_mpz_t()));
115 | }
116 | 
117 | 
118 | void gfp::SHR(const gfp& x,const bigint& n)
119 | {
120 |   SHR(x,mpz_get_si(n.get_mpz_t()));
121 | }
122 | 
123 | 
124 | gfp gfp::sqrRoot()
125 | {
126 |     // Temp move to bigint so as to call sqrRootMod
127 |     bigint ti;
128 |     to_bigint(ti, *this);
129 |     ti = sqrRootMod(ti, ZpD.pr);
130 |     if (!isOdd(ti))
131 |         ti = ZpD.pr - ti;
132 |     gfp temp;
133 |     to_gfp(temp, ti);
134 |     return temp;
135 | }
136 | 


--------------------------------------------------------------------------------
/Math/operators.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * operations.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef MATH_OPERATORS_H_
 9 | #define MATH_OPERATORS_H_
10 | 
11 | template <class T>
12 | T operator*(const bool& x, const T& y) { return x ? y : T(); }
13 | template <class T>
14 | T operator*(const T& y, const bool& x) { return x ? y : T(); }
15 | template <class T>
16 | T& operator*=(const T& y, const bool& x) { y = x ? y : T(); return y; }
17 | 
18 | template <class T, class U>
19 | T operator+(const T& x, const U& y) { T res; res.add(x, y); return res; }
20 | template <class T>
21 | T operator*(const T& x, const T& y) { T res; res.mul(x, y); return res; }
22 | template <class T, class U>
23 | T operator-(const T& x, const U& y) { T res; res.sub(x, y); return res; }
24 | 
25 | template <class T, class U>
26 | T& operator+=(T& x, const U& y) { x.add(y); return x; }
27 | template <class T>
28 | T& operator*=(T& x, const T& y) { x.mul(y); return x; }
29 | template <class T, class U>
30 | T& operator-=(T& x, const U& y) { x.sub(y); return x; }
31 | 
32 | template <class T, class U>
33 | T operator/(const T& x, const U& y) { U inv = y; inv.invert(); return x * inv; }
34 | template <class T, class U>
35 | T& operator/=(const T& x, const U& y) { U inv = y; inv.invert(); return x *= inv; }
36 | 
37 | #endif /* MATH_OPERATORS_H_ */
38 | 


--------------------------------------------------------------------------------
/Networking/Receiver.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * Receiver.cpp
 5 |  *
 6 |  */
 7 | 
 8 | #include "Receiver.h"
 9 | 
10 | #include <iostream>
11 | using namespace std;
12 | 
13 | void* run_receiver_thread(void* receiver)
14 | {
15 |     ((Receiver*)receiver)->run();
16 |     return 0;
17 | }
18 | 
19 | Receiver::Receiver(int socket) : socket(socket), thread(0)
20 | {
21 | }
22 | 
23 | void Receiver::start()
24 | {
25 |     pthread_create(&thread, 0, run_receiver_thread, this);
26 | }
27 | 
28 | void Receiver::stop()
29 | {
30 |     in.stop();
31 |     pthread_join(thread, 0);
32 | }
33 | 
34 | void Receiver::run()
35 | {
36 |     octetStream* os = 0;
37 |     while (in.pop(os))
38 |     {
39 |         os->reset_write_head();
40 |         timer.start();
41 |         os->Receive(socket);
42 |         timer.stop();
43 |         out.push(os);
44 |     }
45 | }
46 | 
47 | void Receiver::request(octetStream& os)
48 | {
49 |     in.push(&os);
50 | }
51 | 
52 | void Receiver::wait(octetStream& os)
53 | {
54 |     octetStream* queued = 0;
55 |     out.pop(queued);
56 |     if (queued != &os)
57 |       throw not_implemented();
58 | }
59 | 


--------------------------------------------------------------------------------
/Networking/Receiver.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * Receiver.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef NETWORKING_RECEIVER_H_
 9 | #define NETWORKING_RECEIVER_H_
10 | 
11 | #include <pthread.h>
12 | 
13 | #include "Tools/octetStream.h"
14 | #include "Tools/WaitQueue.h"
15 | #include "Tools/time-func.h"
16 | 
17 | class Receiver
18 | {
19 |     int socket;
20 |     WaitQueue<octetStream*> in;
21 |     WaitQueue<octetStream*> out;
22 |     pthread_t thread;
23 | 
24 |     // prevent copying
25 |     Receiver(const Receiver& other);
26 | 
27 | public:
28 |     Timer timer;
29 | 
30 |     Receiver(int socket);
31 | 
32 |     void start();
33 |     void stop();
34 |     void run();
35 | 
36 |     void request(octetStream& os);
37 |     void wait(octetStream& os);
38 | };
39 | 
40 | #endif /* NETWORKING_RECEIVER_H_ */
41 | 


--------------------------------------------------------------------------------
/Networking/STS.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef _NETWORK_STS
 4 | #define _NETWORK_STS
 5 | 
 6 | /* The Station to Station protocol
 7 |  */
 8 | 
 9 | #include <iostream>
10 | #include <fstream>
11 | #include <vector>
12 | #include <sodium.h>
13 | 
14 | using namespace std;
15 | 
16 | typedef enum
17 |     { UNKNOWN  // Have not started the interaction or have cleared the memory
18 |     , SENT1    // Sent initial message
19 |     , SENT2    // Received 1, sent 2
20 |     , FINISHED // Done (received msg 2 & sent 3 or received msg 3)
21 |     , UNDEFINED // For arrays/vectors/etc of STS classes that are initialized later.
22 | } phase_t;
23 | 
24 | struct msg1_st {
25 |     unsigned char bytes[crypto_box_PUBLICKEYBYTES];
26 | };
27 | typedef struct msg1_st sts_msg1_t;
28 | struct msg2_st {
29 |     unsigned char pubkey[crypto_box_PUBLICKEYBYTES];
30 |     unsigned char sig[crypto_sign_BYTES];
31 | };
32 | typedef struct msg2_st sts_msg2_t;
33 | struct msg3_st {
34 |     unsigned char bytes[crypto_sign_BYTES];
35 | };
36 | typedef struct msg3_st sts_msg3_t;
37 | 
38 | class STS
39 | {
40 |     phase_t phase;
41 |     unsigned char their_public_sign_key[crypto_sign_PUBLICKEYBYTES];
42 |     unsigned char my_public_sign_key[crypto_sign_PUBLICKEYBYTES];
43 |     unsigned char my_private_sign_key[crypto_sign_SECRETKEYBYTES];
44 |     unsigned char ephemeral_private_key[crypto_box_SECRETKEYBYTES];
45 |     unsigned char ephemeral_public_key[crypto_box_PUBLICKEYBYTES];
46 |     unsigned char their_ephemeral_public_key[crypto_box_PUBLICKEYBYTES];
47 |     unsigned char raw_secret[crypto_hash_sha512_BYTES];
48 |     uint64_t kdf_counter;
49 |   public:
50 |     STS();
51 |     STS( const unsigned char theirPub[crypto_sign_PUBLICKEYBYTES]
52 |        , const unsigned char myPub[crypto_sign_PUBLICKEYBYTES]
53 |        , const unsigned char myPriv[crypto_sign_SECRETKEYBYTES]);
54 |     ~STS();
55 | 
56 |     void init( const unsigned char theirPub[crypto_sign_PUBLICKEYBYTES]
57 |              , const unsigned char myPub[crypto_sign_PUBLICKEYBYTES]
58 |              , const unsigned char myPriv[crypto_sign_SECRETKEYBYTES]);
59 | 
60 |     sts_msg1_t send_msg1();
61 |     sts_msg3_t recv_msg2(sts_msg2_t msg2);
62 | 
63 |     sts_msg2_t recv_msg1(sts_msg1_t msg1);
64 |     void recv_msg3(sts_msg3_t msg3);
65 | 
66 |     vector<unsigned char> derive_secret(size_t);
67 |   private:
68 |     vector<unsigned char> unsafe_derive_secret(size_t);
69 |     void kdf_block(unsigned char *block);
70 | };
71 | 
72 | #endif /* _NETWORK_STS */
73 | 


--------------------------------------------------------------------------------
/Networking/Sender.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * Sender.cpp
 5 |  *
 6 |  */
 7 | 
 8 | #include "Sender.h"
 9 | 
10 | void* run_sender_thread(void* sender)
11 | {
12 |     ((Sender*)sender)->run();
13 |     return 0;
14 | }
15 | 
16 | Sender::Sender(int socket) : socket(socket), thread(0)
17 | {
18 | }
19 | 
20 | void Sender::start()
21 | {
22 |     pthread_create(&thread, 0, run_sender_thread, this);
23 | }
24 | 
25 | void Sender::stop()
26 | {
27 |     in.stop();
28 |     pthread_join(thread, 0);
29 | }
30 | 
31 | void Sender::run()
32 | {
33 |     const octetStream* os = 0;
34 |     while (in.pop(os))
35 |     {
36 | //        timer.start();
37 |         os->Send(socket);
38 | //        timer.stop();
39 |         out.push(os);
40 |     }
41 | }
42 | 
43 | void Sender::request(const octetStream& os)
44 | {
45 |     in.push(&os);
46 | }
47 | 
48 | void Sender::wait(const octetStream& os)
49 | {
50 |     const octetStream* queued = 0;
51 |     out.pop(queued);
52 |     if (queued != &os)
53 |       throw not_implemented();
54 | }
55 | 


--------------------------------------------------------------------------------
/Networking/Sender.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * Sender.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef NETWORKING_SENDER_H_
 9 | #define NETWORKING_SENDER_H_
10 | 
11 | #include <pthread.h>
12 | 
13 | #include "Tools/octetStream.h"
14 | #include "Tools/WaitQueue.h"
15 | #include "Tools/time-func.h"
16 | 
17 | class Sender
18 | {
19 |     int socket;
20 |     WaitQueue<const octetStream*> in;
21 |     WaitQueue<const octetStream*> out;
22 |     pthread_t thread;
23 | 
24 |     // prevent copying
25 |     Sender(const Sender& other);
26 | 
27 | public:
28 |     Timer timer;
29 | 
30 |     Sender(int socket);
31 | 
32 |     void start();
33 |     void stop();
34 |     void run();
35 | 
36 |     void request(const octetStream& os);
37 |     void wait(const octetStream& os);
38 | };
39 | 
40 | #endif /* NETWORKING_SENDER_H_ */
41 | 


--------------------------------------------------------------------------------
/Networking/Server.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * Server.h
 5 |  */
 6 | 
 7 | #ifndef NETWORKING_SERVER_H_
 8 | #define NETWORKING_SERVER_H_
 9 | 
10 | #include "Networking/data.h"
11 | #include "Networking/Player.h"
12 | 
13 | #include <vector>
14 | using namespace std;
15 | 
16 | class Server
17 | {
18 |     vector<int> socket_num;
19 |     vector<octet*> names;
20 |     vector<int> ports;
21 |     int nmachines;
22 |     int PortnumBase;
23 | 
24 |     void get_ip(int num);
25 |     void get_name(int num);
26 |     void send_names(int num);
27 | 
28 | public:
29 |     static void* start_in_thread(void* server);
30 |     static Server* start_networking(Names& N, int my_num, int nplayers,
31 |             string hostname = "localhost", int portnum = 9000);
32 | 
33 |     Server(int argc, char** argv);
34 |     Server(int nmachines, int PortnumBase);
35 |     void start();
36 | };
37 | 
38 | #endif /* NETWORKING_SERVER_H_ */
39 | 


--------------------------------------------------------------------------------
/Networking/ServerSocket.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * ServerSocket.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef NETWORKING_SERVERSOCKET_H_
 9 | #define NETWORKING_SERVERSOCKET_H_
10 | 
11 | #include <map>
12 | #include <set>
13 |  #include <queue>
14 | using namespace std;
15 | 
16 | #include <pthread.h>
17 | 
18 | #include "Tools/WaitQueue.h"
19 | #include "Tools/Signal.h"
20 | 
21 | class ServerSocket
22 | {
23 | protected:
24 |     int main_socket, portnum;
25 |     map<int,int> clients;
26 |     std::set<int> used;
27 |     Signal data_signal;
28 |     pthread_t thread;
29 | 
30 |     // disable copying
31 |     ServerSocket(const ServerSocket& other);
32 | 
33 |     // receive id from client
34 |     int assign_client_id(int consocket);
35 | 
36 | public:
37 |     ServerSocket(int Portnum);
38 |     virtual ~ServerSocket();
39 | 
40 |     virtual void init();
41 | 
42 |     virtual void accept_clients();
43 | 
44 |     // This depends on clients sending their id as int.
45 |     // Has to be thread-safe.
46 |     int get_connection_socket(int number);
47 | 
48 |     // How many client connections have been made.
49 |     virtual int get_connection_count();
50 | 
51 |     void close_socket();
52 | };
53 | 
54 | /*
55 |  * ServerSocket where clients do not send any identifiers upon connecting.
56 |  */
57 | class AnonymousServerSocket : public ServerSocket
58 | {
59 | private:
60 |     // Global no. of client sockets that have been returned - used to create identifiers
61 |     static int global_client_socket_count;
62 |     // No. of accepted connections in this instance
63 |     int num_accepted_clients;
64 |     queue<int> client_connection_queue;
65 | 
66 | public:
67 |     AnonymousServerSocket(int Portnum) :
68 |         ServerSocket(Portnum), num_accepted_clients(0) { };
69 |     // override so clients do not send id
70 |     void accept_clients();
71 |     void init();
72 | 
73 |     virtual int get_connection_count();
74 | 
75 |     // Get socket for the last client who connected
76 |     // Writes a unique client identifier (i.e. a counter) to client_id
77 |     int get_connection_socket(int& client_id);
78 | };
79 | 
80 | #endif /* NETWORKING_SERVERSOCKET_H_ */
81 | 


--------------------------------------------------------------------------------
/Networking/data.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef _Data
 4 | #define _Data
 5 | 
 6 | #include <string.h>
 7 | 
 8 | #include "Exceptions/Exceptions.h"
 9 | 
10 | 
11 | typedef unsigned char octet;
12 | 
13 | // Assumes word is a 64 bit value
14 | #ifdef WIN32
15 |   typedef unsigned __int64 word;
16 | #else
17 |   typedef unsigned long word;
18 | #endif
19 | 
20 | #define BROADCAST 0
21 | #define ROUTE     1
22 | #define TERMINATE 2
23 | #define GO        3
24 | 
25 | 
26 | inline void encode_length(octet *buff, size_t len, size_t n_bytes)
27 | {
28 |     if (n_bytes > 8)
29 |         throw invalid_length("length field cannot be more than 64 bits");
30 |     if (n_bytes < 8 && (len > (1ULL << (8 * n_bytes))))
31 |         throw invalid_length("length too large for length field");
32 |     for (size_t i = 0; i < n_bytes; i++)
33 |         buff[i] = len >> (8 * i);
34 | }
35 | 
36 | inline size_t decode_length(octet *buff, size_t n_bytes)
37 | {
38 |     size_t len = 0;
39 |     for (size_t i = 0; i < n_bytes; i++)
40 |     {
41 |         len += (size_t) buff[i] << (8 * i);
42 |     }
43 |     return len;
44 | }
45 | 
46 | #endif
47 | 


--------------------------------------------------------------------------------
/Networking/sockets.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef _sockets
 4 | #define _sockets
 5 | 
 6 | #include "Networking/data.h"
 7 | 
 8 | #include <errno.h>      /* Errors */
 9 | #include <stdio.h>
10 | #include <stdlib.h>
11 | #include <string.h>
12 | #include <time.h>
13 | #include <unistd.h>
14 | 
15 | #include <netdb.h>
16 | #include <netinet/in.h>
17 | #include <netinet/tcp.h>
18 | 
19 | #include <arpa/inet.h>
20 | 
21 | #include <sys/socket.h>
22 | #include <sys/types.h>
23 | #include <sys/wait.h>   /* Wait for Process Termination */
24 | 
25 | #include <iostream>
26 | using namespace std;
27 | 
28 | 
29 | void error(const char *str1,const char *str2);
30 | void error(const char *str);
31 | 
32 | void set_up_server_socket(sockaddr_in& dest,int& consocket,int& main_socket,int Portnum);
33 | void close_server_socket(int consocket,int main_socket);
34 | 
35 | void set_up_client_socket(int& mysocket,const char* hostname,int Portnum);
36 | void close_client_socket(int socket);
37 | 
38 | /* Send and receive 8 bit integers */
39 | void send(int socket,int a);
40 | void receive(int socket,int& a);
41 | 
42 | // same for words
43 | void send(int socket, size_t a, size_t len);
44 | void receive(int socket, size_t& a, size_t len);
45 | 
46 | void send_ack(int socket);
47 | int get_ack(int socket);
48 | 
49 | 
50 | extern unsigned long long sent_amount, sent_counter;
51 | 
52 | inline void send(int socket,octet *msg,size_t len)
53 | {
54 |   size_t i = 0;
55 |   while (i < len)
56 |     {
57 |       int j = send(socket,msg+i,len-i,0);
58 |       i += j;
59 |       if (j < 0 and errno != EINTR)
60 |         { error("Send error - 1 ");  }
61 |     }
62 | 
63 |   sent_amount += len;
64 |   sent_counter++;
65 | }
66 | 
67 | inline void receive(int socket,octet *msg,size_t len)
68 | {
69 |   size_t i=0;
70 |   int fail = 0;
71 |   while (len-i>0)
72 |     { int j=recv(socket,msg+i,len-i,0);
73 |       if (j<0)
74 |         {
75 |           if (errno == EAGAIN or errno == EINTR)
76 |             {
77 |               if (++fail > 100)
78 |                 error("Unavailable too many times");
79 |               else
80 |                 {
81 |                   cout << "Unavailable, trying again in 1 ms" << endl;
82 |                   usleep(1000);
83 |                 }
84 |             }
85 |           else
86 |             { error("Receiving error - 1"); }
87 |         }
88 |       else
89 |         i=i+j;
90 |     }
91 | }
92 | 
93 | #endif
94 | 


--------------------------------------------------------------------------------
/OT/BaseOT.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef _BASE_OT
 4 | #define _BASE_OT
 5 | 
 6 | /* The OT thread uses the Miracl library, which is not thread safe.
 7 |  * Thus all Miracl based code is contained in this one thread so as
 8 |  * to avoid locking issues etc.
 9 |  *
10 |  * Thus this thread serves all base OTs to all other threads
11 |  */
12 | 
13 | #include "Networking/Player.h"
14 | #include "Tools/random.h"
15 | #include "OT/BitVector.h"
16 | 
17 | // currently always assumes BOTH, i.e. do 2 sets of OT symmetrically,
18 | // use bitwise & to check for role
19 | enum OT_ROLE
20 | {
21 | 	RECEIVER = 0x01,
22 | 	SENDER = 0x10,
23 | 	BOTH = 0x11
24 | };
25 | 
26 | OT_ROLE INV_ROLE(OT_ROLE role);
27 | 
28 | const char* role_to_str(OT_ROLE role);
29 | void send_if_ot_sender(TwoPartyPlayer* P, vector<octetStream>& os, OT_ROLE role);
30 | void send_if_ot_receiver(TwoPartyPlayer* P, vector<octetStream>& os, OT_ROLE role);
31 | 
32 | class BaseOT
33 | {
34 | public:
35 | 	vector<int> receiver_inputs;
36 | 	vector< vector<BitVector> > sender_inputs;
37 | 	vector<BitVector> receiver_outputs;
38 | 	TwoPartyPlayer* P;
39 | 
40 | 	BaseOT(int nOT, int ot_length, TwoPartyPlayer* player, OT_ROLE role=BOTH)
41 | 		: P(player), nOT(nOT), ot_length(ot_length), ot_role(role)
42 | 	{
43 | 		receiver_inputs.resize(nOT);
44 | 		sender_inputs.resize(nOT, vector<BitVector>(2));
45 | 		receiver_outputs.resize(nOT);
46 | 		G_sender.resize(nOT, vector<PRNG>(2));
47 | 		G_receiver.resize(nOT);
48 | 
49 | 		for (int i = 0; i < nOT; i++)
50 | 		{
51 | 			sender_inputs[i][0] = BitVector(8 * AES_BLK_SIZE);
52 | 			sender_inputs[i][1] = BitVector(8 * AES_BLK_SIZE);
53 | 			receiver_outputs[i] = BitVector(8 * AES_BLK_SIZE);
54 | 		}
55 | 	}
56 | 	virtual ~BaseOT() {}
57 | 
58 | 	int length() { return ot_length; }
59 | 
60 | 	void set_receiver_inputs(const vector<int>& new_inputs)
61 | 	{
62 | 		if ((int)new_inputs.size() != nOT)
63 | 			throw invalid_length();
64 | 		receiver_inputs = new_inputs;
65 | 	}
66 | 
67 | 	// do the OTs -- generate fresh random choice bits by default
68 | 	virtual void exec_base(bool new_receiver_inputs=true);
69 | 	// use PRG to get the next ot_length bits
70 | 	void extend_length();
71 | 	void check();
72 | protected:
73 | 	int nOT, ot_length;
74 | 	OT_ROLE ot_role;
75 | 
76 | 	vector< vector<PRNG> > G_sender;
77 | 	vector<PRNG> G_receiver;
78 | 
79 | 	bool is_sender() { return (bool) (ot_role & SENDER); }
80 | 	bool is_receiver() { return (bool) (ot_role & RECEIVER); }
81 | 
82 | 	void set_seeds();
83 | };
84 | 
85 | class FakeOT : public BaseOT
86 | {
87 | public:
88 |    FakeOT(int nOT, int ot_length, TwoPartyPlayer* player, OT_ROLE role=BOTH) :
89 |        BaseOT(nOT, ot_length, player, role) {}
90 |    void exec_base(bool new_receiver_inputs=true);
91 | };
92 | 
93 | #endif
94 | 


--------------------------------------------------------------------------------
/OT/BitVector.cpp:
--------------------------------------------------------------------------------
  1 | // (C) 2018 University of Bristol. See License.txt
  2 | 
  3 | 
  4 | #include "OT/BitVector.h"
  5 | #include "Tools/random.h"
  6 | #include "Tools/octetStream.h"
  7 | #include "Math/gf2n.h"
  8 | #include "Math/gfp.h"
  9 | 
 10 | #include <fstream>
 11 | 
 12 | void BitVector::randomize(PRNG& G)
 13 | {
 14 |     G.get_octets(bytes, nbytes);
 15 | }
 16 | 
 17 | template<>
 18 | void BitVector::randomize_blocks<gf2n>(PRNG& G)
 19 | {
 20 |     randomize(G);
 21 | }
 22 | 
 23 | template<>
 24 | void BitVector::randomize_blocks<gfp>(PRNG& G)
 25 | {
 26 |     gfp tmp;
 27 |     for (size_t i = 0; i < (nbits / 128); i++)
 28 |     {
 29 |         tmp.randomize(G);
 30 |         for (int j = 0; j < 2; j++)
 31 |             ((mp_limb_t*)bytes)[2*i+j] = tmp.get().get_limb(j);
 32 |     }
 33 | }
 34 | 
 35 | void BitVector::randomize_at(int a, int nb, PRNG& G)
 36 | {
 37 |     if (nb < 1)
 38 |         throw invalid_length();
 39 |     G.get_octets(bytes + a, nb);
 40 | }
 41 | 
 42 | /*
 43 |  */
 44 | 
 45 | void BitVector::output(ostream& s,bool human) const
 46 | {
 47 |     if (human)
 48 |     {
 49 |         s << nbits << " " << hex;
 50 |         for (unsigned int i = 0; i < nbytes; i++)
 51 |         {
 52 |             s << int(bytes[i]) << " ";
 53 |         }
 54 |         s << dec << endl;
 55 |     }
 56 |     else
 57 |     {
 58 |         int len = nbits;
 59 |         s.write((char*) &len, sizeof(int));
 60 |         s.write((char*) bytes, nbytes);
 61 |     }
 62 | }
 63 | 
 64 | 
 65 | void BitVector::input(istream& s,bool human)
 66 | {
 67 |     if (s.peek() == EOF)
 68 |     {
 69 |         if (s.tellg() == 0)
 70 |         {
 71 |             cout << "IO problem. Empty file?" << endl;
 72 |             throw file_error();
 73 |         }
 74 |       throw end_of_file();
 75 |     }
 76 |     int len;
 77 |     if (human)
 78 |     {
 79 |         s >> len >> hex;
 80 |         resize(len);
 81 |         for (size_t i = 0; i < nbytes; i++)
 82 |         {
 83 |             s >> bytes[i];
 84 |         }
 85 |         s >> dec;
 86 |     }
 87 |     else
 88 |     {
 89 |         s.read((char*) &len, sizeof(int));
 90 |         resize(len);
 91 |         s.read((char*) bytes, nbytes);
 92 |     }
 93 | }
 94 | 
 95 | 
 96 | void BitVector::pack(octetStream& o) const
 97 | {
 98 |     o.append((octet*)bytes, nbytes);
 99 | }
100 | 
101 | 
102 | void BitVector::unpack(octetStream& o)
103 | {
104 |     o.consume((octet*)bytes, nbytes);
105 | }
106 | 
107 | 
108 | 


--------------------------------------------------------------------------------
/OT/NPartyTripleGenerator.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef OT_NPARTYTRIPLEGENERATOR_H_
 4 | #define OT_NPARTYTRIPLEGENERATOR_H_
 5 | 
 6 | #include "Networking/Player.h"
 7 | #include "OT/BaseOT.h"
 8 | #include "Tools/random.h"
 9 | #include "Tools/time-func.h"
10 | #include "Math/gfp.h"
11 | #include "Auth/MAC_Check.h"
12 | 
13 | #include "OT/OTTripleSetup.h"
14 | #include "OT/TripleMachine.h"
15 | #include "OT/OTMultiplier.h"
16 | 
17 | #include <map>
18 | #include <vector>
19 | 
20 | #define N_AMPLIFY 3
21 | 
22 | template <class T, int N>
23 | class ShareTriple;
24 | 
25 | class NPartyTripleGenerator
26 | {
27 |     //OTTripleSetup* setup;
28 |     Player globalPlayer;
29 | 
30 |     int thread_num;
31 |     int my_num;
32 |     int nbase;
33 | 
34 |     struct timeval last_lap;
35 | 
36 |     pthread_mutex_t mutex;
37 |     pthread_cond_t ready;
38 | 
39 |     template <class T>
40 |     void generateTriples(vector< OTMultiplier<T>* >& ot_multipliers, ofstream& outputFile);
41 |     template <class T>
42 |     void generateBits(vector< OTMultiplier<T>* >& ot_multipliers, ofstream& outputFile);
43 |     template <class T, int N>
44 |     void generateBitsFromTriples(vector<ShareTriple<T, N> >& triples,
45 |             MAC_Check<T>& MC, ofstream& outputFile);
46 | 
47 |     template <class T>
48 |     void start_progress(vector< OTMultiplier<T>* >& ot_multipliers);
49 |     void print_progress(int k);
50 | 
51 | public:
52 |     // TwoPartyPlayer's for OTs, n-party Player for sacrificing
53 |     vector<TwoPartyPlayer*> players;
54 |     //vector<OTMachine*> machines;
55 |     BitVector baseReceiverInput; // same for every set of OTs
56 |     vector< vector< vector<BitVector> > > baseSenderInputs;
57 |     vector< vector<BitVector> > baseReceiverOutputs;
58 |     vector<BitVector> valueBits;
59 | 
60 |     int nTriples;
61 |     int nTriplesPerLoop;
62 |     int nloops;
63 |     int field_size;
64 |     int nAmplify;
65 |     int nPreampTriplesPerLoop;
66 |     int repeat[3];
67 |     int nparties;
68 | 
69 |     TripleMachine& machine;
70 | 
71 |     map<string,Timer> timers;
72 | 
73 |     NPartyTripleGenerator(OTTripleSetup& setup, const Names& names, int thread_num, int nTriples, int nloops, TripleMachine& machine);
74 |     ~NPartyTripleGenerator();
75 |     template <class T>
76 |     void generate();
77 | 
78 |     void lock();
79 |     void unlock();
80 |     void signal();
81 |     void wait();
82 | };
83 | 
84 | #endif
85 | 


--------------------------------------------------------------------------------
/OT/OTExtensionWithMatrix.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * OTExtensionWithMatrix.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef OT_OTEXTENSIONWITHMATRIX_H_
 9 | #define OT_OTEXTENSIONWITHMATRIX_H_
10 | 
11 | #include "OTExtension.h"
12 | #include "BitMatrix.h"
13 | #include "Math/gf2n.h"
14 | 
15 | class OTExtensionWithMatrix : public OTExtension
16 | {
17 | public:
18 |     vector<BitMatrix> senderOutputMatrices;
19 |     BitMatrix receiverOutputMatrix;
20 |     BitMatrix t1, u;
21 |     PRNG G;
22 | 
23 |     OTExtensionWithMatrix(int nbaseOTs, int baseLength,
24 |                 int nloops, int nsubloops,
25 |                 TwoPartyPlayer* player,
26 |                 BitVector& baseReceiverInput,
27 |                 vector< vector<BitVector> >& baseSenderInput,
28 |                 vector<BitVector>& baseReceiverOutput,
29 |                 OT_ROLE role=BOTH,
30 |                 bool passive=false)
31 |     : OTExtension(nbaseOTs, baseLength, nloops, nsubloops, player, baseReceiverInput,
32 |             baseSenderInput, baseReceiverOutput, role, passive) {
33 |       G.ReSeed();
34 |     }
35 | 
36 |     void seed(vector<BitMatrix>& baseSenderInput,
37 |             BitMatrix& baseReceiverOutput);
38 |     void transfer(int nOTs, const BitVector& receiverInput);
39 |     void resize(int nOTs);
40 |     template <class T>
41 |     void extend(int nOTs, BitVector& newReceiverInput);
42 |     template <class T>
43 |     void expand(int start, int slice);
44 |     template <class T>
45 |     void expand_transposed();
46 |     template <class T>
47 |     void correlate(int start, int slice, BitVector& newReceiverInput, bool useConstantBase, int repeat = 1);
48 |     void transpose(int start, int slice);
49 |     void setup_for_correlation(vector<BitMatrix>& baseSenderOutputs, BitMatrix& baseReceiverOutput);
50 |     template <class T>
51 |     void reduce_squares(unsigned int nTriples, vector<T>& output);
52 | 
53 |     void print(BitVector& newReceiverInput, int i = 0);
54 |     template <class T>
55 |     void print_receiver(BitVector& newReceiverInput, BitMatrix& matrix, int i = 0, int offset = 0);
56 |     void print_sender(square128& square0, square128& square);
57 |     template <class T>
58 |     void print_post_correlate(BitVector& newReceiverInput, int i = 0, int offset = 0, int sender = 0);
59 |     void print_pre_correlate(int i = 0);
60 |     void print_post_transpose(BitVector& newReceiverInput, int i = 0,  int sender = 0);
61 |     void print_pre_expand();
62 | 
63 |     octet* get_receiver_output(int i);
64 |     octet* get_sender_output(int choice, int i);
65 | 
66 | protected:
67 |     template <class T>
68 |     void hash_outputs(int nOTs);
69 | };
70 | 
71 | #endif /* OT_OTEXTENSIONWITHMATRIX_H_ */
72 | 


--------------------------------------------------------------------------------
/OT/OTMachine.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * OTMachine.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef OT_OTMACHINE_H_
 9 | #define OT_OTMACHINE_H_
10 | 
11 | #include "OT/OTExtension.h"
12 | #include "Tools/ezOptionParser.h"
13 | 
14 | class OTMachine
15 | {
16 |     ez::ezOptionParser opt;
17 |     OT_ROLE ot_role;
18 | 
19 | public:
20 |     int my_num, portnum_base, nthreads, nloops, nsubloops, nbase;
21 |     long nOTs;
22 |     bool passive;
23 |     TwoPartyPlayer* P;
24 |     BitVector baseReceiverInput;
25 |     BaseOT* bot_;
26 |     vector<Names*> N;
27 | 
28 |     OTMachine(int argc, const char** argv);
29 |     ~OTMachine();
30 |     void run();
31 | };
32 | 
33 | #endif /* OT_OTMACHINE_H_ */
34 | 


--------------------------------------------------------------------------------
/OT/OTMultiplier.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * OTMultiplier.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef OT_OTMULTIPLIER_H_
 9 | #define OT_OTMULTIPLIER_H_
10 | 
11 | #include <vector>
12 | using namespace std;
13 | 
14 | #include "OT/OTExtensionWithMatrix.h"
15 | #include "Tools/random.h"
16 | 
17 | class NPartyTripleGenerator;
18 | 
19 | template <class T>
20 | class OTMultiplier
21 | {
22 | 	void multiplyForTriples(OTExtensionWithMatrix& auth_ot_ext);
23 | 	void multiplyForBits(OTExtensionWithMatrix& auth_ot_ext);
24 | public:
25 |     NPartyTripleGenerator& generator;
26 |     int thread_num;
27 |     OTExtensionWithMatrix rot_ext;
28 |     //OTExtensionWithMatrix* auth_ot_ext;
29 |     vector<T> c_output;
30 |     vector< vector<T> > macs;
31 | 
32 |     pthread_t thread;
33 |     pthread_mutex_t mutex;
34 |     pthread_cond_t ready;
35 | 
36 |     OTMultiplier(NPartyTripleGenerator& generator, int thread_num);
37 |     ~OTMultiplier();
38 |     void multiply();
39 | };
40 | 
41 | #endif /* OT_OTMULTIPLIER_H_ */
42 | 


--------------------------------------------------------------------------------
/OT/OTTripleSetup.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #include "OTTripleSetup.h"
 4 | 
 5 | void OTTripleSetup::setup()
 6 | {
 7 |     timeval baseOTstart, baseOTend;
 8 |     gettimeofday(&baseOTstart, NULL);
 9 | 
10 |     G.ReSeed();
11 |     for (int i = 0; i < nbase; i++)
12 |     {
13 |         base_receiver_inputs[i] = G.get_uchar() & 1;
14 |     }
15 |     //baseReceiverInput.randomize(G);
16 | 
17 |     for (int i = 0; i < nparties - 1; i++)
18 |     {
19 |         baseOTs[i]->set_receiver_inputs(base_receiver_inputs);
20 |         baseOTs[i]->exec_base(false);
21 |     }
22 |     gettimeofday(&baseOTend, NULL);
23 |     double basetime = timeval_diff(&baseOTstart, &baseOTend);
24 |     cout << "\t\tBaseTime: " << basetime/1000000 << endl << flush;
25 | 
26 |     // Receiver send something to force synchronization
27 |     // (since Sender finishes baseOTs before Receiver)
28 | }
29 | 
30 | void OTTripleSetup::close_connections()
31 | {
32 |     for (size_t i = 0; i < players.size(); i++)
33 |     {
34 |         delete players[i];
35 |     }
36 | }
37 | 
38 | OTTripleSetup::~OTTripleSetup()
39 | {
40 |     for (size_t i = 0; i < baseOTs.size(); i++)
41 |     {
42 |         delete baseOTs[i];
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/OT/OTTripleSetup.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef OT_TRIPLESETUP_H_
 4 | #define OT_TRIPLESETUP_H_
 5 | 
 6 | #include "Networking/Player.h"
 7 | #include "OT/BaseOT.h"
 8 | #include "OT/OTMachine.h"
 9 | #include "Tools/random.h"
10 | #include "Tools/time-func.h"
11 | #include "Math/gfp.h"
12 | 
13 | /*
14 |  * Class for creating and storing base OTs between every pair of parties.
15 |  */
16 | class OTTripleSetup
17 | {
18 |     vector<int> base_receiver_inputs;
19 |     vector< vector< vector<BitVector> > > baseSenderInputs;
20 |     vector< vector<BitVector> > baseReceiverOutputs;
21 | 
22 |     PRNG G;
23 |     int nparties;
24 |     int my_num;
25 |     int nbase;
26 | 
27 | public:
28 |     map<string,Timer> timers;
29 |     vector<BaseOT*> baseOTs;
30 |     vector<TwoPartyPlayer*> players;
31 | 
32 |     int get_nparties() { return nparties; }
33 |     int get_nbase() { return nbase; }
34 |     int get_my_num() { return my_num; }
35 |     int get_base_receiver_input(int i) { return base_receiver_inputs[i]; }
36 | 
37 |     OTTripleSetup(Names& N, bool real_OTs)
38 |         : nparties(N.num_players()), my_num(N.my_num()), nbase(128)
39 |     {
40 |         base_receiver_inputs.resize(nbase);
41 |         players.resize(nparties - 1);
42 |         baseOTs.resize(nparties - 1);
43 |         baseSenderInputs.resize(nparties - 1);
44 |         baseReceiverOutputs.resize(nparties - 1);
45 | 
46 |         if (real_OTs)
47 |             cout << "Doing real base OTs\n";
48 |         else
49 |             cout << "Doing fake base OTs\n";
50 | 
51 |         for (int i = 0; i < nparties - 1; i++)
52 |         {
53 |             int other_player, id;
54 |             // i for indexing, other_player is actual number
55 |             if (i >= my_num)
56 |                 other_player = i + 1;
57 |             else
58 |                 other_player = i;
59 |             // unique id per pair of parties (to assign port no.)
60 |             if (my_num < other_player)
61 |                 id = my_num*nparties + other_player;
62 |             else
63 |                 id = other_player*nparties + my_num;
64 | 
65 |             players[i] = new TwoPartyPlayer(N, other_player, id);
66 | 
67 |             // sets up a pair of base OTs, playing both roles
68 |             if (real_OTs)
69 |             {
70 |                 baseOTs[i] = new BaseOT(nbase, 128, players[i]);
71 |             }
72 |             else
73 |             {
74 |                 baseOTs[i] = new FakeOT(nbase, 128, players[i]);
75 |             }
76 |         }
77 |     }
78 |     ~OTTripleSetup();
79 | 
80 |     // run the Base OTs
81 |     void setup();
82 |     // close down the sockets
83 |     void close_connections();
84 | 
85 |     //template <class T>
86 |     //T get_mac_key();
87 | };
88 | 
89 | 
90 | #endif
91 | 


--------------------------------------------------------------------------------
/OT/OText_main.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * OText_main.cpp
 5 |  *
 6 |  */
 7 | 
 8 | #include "OTMachine.h"
 9 | 
10 | int main(int argc, const char** argv)
11 | {
12 |     OTMachine(argc, argv).run();
13 | }
14 | 


--------------------------------------------------------------------------------
/OT/OutputCheck.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * check.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef OT_OUTPUTCHECK_H_
 9 | #define OT_OUTPUTCHECK_H_
10 | 
11 | #include "Math/Setup.h"
12 | 
13 | #define RECEIVER_INPUT PREP_DIR "OT-receiver%d-input"
14 | #define RECEIVER_OUTPUT PREP_DIR "OT-receiver%d-output"
15 | #define SENDER_OUTPUT PREP_DIR "OT-sender%d-output%d"
16 | 
17 | #endif /* OT_OUTPUTCHECK_H_ */
18 | 


--------------------------------------------------------------------------------
/OT/Tools.cpp:
--------------------------------------------------------------------------------
  1 | // (C) 2018 University of Bristol. See License.txt
  2 | 
  3 | #include "Tools.h"
  4 | #include "Math/gf2nlong.h"
  5 | 
  6 | void random_seed_commit(octet* seed, TwoPartyPlayer& player, int len)
  7 | {
  8 | 	PRNG G;
  9 | 	G.ReSeed();
 10 | 	vector<octetStream> seed_strm(2);
 11 | 	vector<octetStream> Comm_seed(2);
 12 |   	vector<octetStream> Open_seed(2);
 13 | 	G.get_octetStream(seed_strm[0], len);
 14 | 
 15 | 	Commit(Comm_seed[0], Open_seed[0], seed_strm[0], player.my_real_num());
 16 | 	player.send_receive_player(Comm_seed);
 17 | 	player.send_receive_player(Open_seed);
 18 | 
 19 | 	memset(seed, 0, len*sizeof(octet));
 20 | 
 21 |   	if (!Open(seed_strm[1], Comm_seed[1], Open_seed[1], player.other_player_num()))
 22 |     {
 23 |     	throw invalid_commitment();
 24 |     }
 25 |     for (int i = 0; i < len; i++)
 26 | 	{
 27 | 		seed[i] = seed_strm[0].get_data()[i] ^ seed_strm[1].get_data()[i];
 28 |     }
 29 | }
 30 | 
 31 | void shiftl128(word x1, word x2, word& res1, word& res2, size_t k)
 32 | {
 33 |     if (k > 128)
 34 |         throw invalid_length();
 35 |     if (k >= 64) // shifting a 64-bit integer by more than 63 bits is "undefined"
 36 |     {
 37 |         x1 = x2;
 38 |         x2 = 0;
 39 |         shiftl128(x1, x2, res1, res2, k - 64);
 40 |     }
 41 |     else
 42 |     {
 43 |         res1 = (x1 << k) | (x2 >> (64-k));
 44 |         res2 = (x2 << k);
 45 |     }
 46 | }
 47 | 
 48 | // reduce modulo x^128 + x^7 + x^2 + x + 1
 49 | // NB this is incorrect as it bit-reflects the result as required for
 50 | // GCM mode
 51 | void gfred128(__m128i tmp3, __m128i tmp6, __m128i *res)
 52 | {
 53 |     __m128i tmp2, tmp4, tmp5, tmp7, tmp8, tmp9;
 54 |     tmp7 = _mm_srli_epi32(tmp3, 31);
 55 |     tmp8 = _mm_srli_epi32(tmp6, 31);
 56 | 
 57 |     tmp3 = _mm_slli_epi32(tmp3, 1);
 58 |     tmp6 = _mm_slli_epi32(tmp6, 1);
 59 | 
 60 |     tmp9 = _mm_srli_si128(tmp7, 12);
 61 |     tmp8 = _mm_slli_si128(tmp8, 4);
 62 |     tmp7 = _mm_slli_si128(tmp7, 4);
 63 |     tmp3 = _mm_or_si128(tmp3, tmp7);
 64 |     tmp6 = _mm_or_si128(tmp6, tmp8);
 65 |     tmp6 = _mm_or_si128(tmp6, tmp9);
 66 | 
 67 |     tmp7 = _mm_slli_epi32(tmp3, 31);
 68 |     tmp8 = _mm_slli_epi32(tmp3, 30);
 69 |     tmp9 = _mm_slli_epi32(tmp3, 25);
 70 | 
 71 |     tmp7 = _mm_xor_si128(tmp7, tmp8);
 72 |     tmp7 = _mm_xor_si128(tmp7, tmp9);
 73 |     tmp8 = _mm_srli_si128(tmp7, 4);
 74 |     tmp7 = _mm_slli_si128(tmp7, 12);
 75 |     tmp3 = _mm_xor_si128(tmp3, tmp7);
 76 | 
 77 |     tmp2 = _mm_srli_epi32(tmp3, 1);
 78 |     tmp4 = _mm_srli_epi32(tmp3, 2);
 79 |     tmp5 = _mm_srli_epi32(tmp3, 7);
 80 |     tmp2 = _mm_xor_si128(tmp2, tmp4);
 81 |     tmp2 = _mm_xor_si128(tmp2, tmp5);
 82 |     tmp2 = _mm_xor_si128(tmp2, tmp8);
 83 |     tmp3 = _mm_xor_si128(tmp3, tmp2);
 84 | 
 85 |     tmp6 = _mm_xor_si128(tmp6, tmp3);
 86 |     *res = tmp6;
 87 | }
 88 | 
 89 | // Based on Intel's code for GF(2^128) mul, with reduction
 90 | void gfmul128 (__m128i a, __m128i b, __m128i *res)
 91 | {
 92 |     __m128i tmp3, tmp6;
 93 |     mul128(a, b, &tmp3, &tmp6);
 94 |     // Now do the reduction
 95 |     gfred128(tmp3, tmp6, res);
 96 | }
 97 | 
 98 | string word_to_bytes(const word w)
 99 | {
100 |     stringstream ss;
101 |     octet* bytes = (octet*) &w;
102 |     ss << hex;
103 |     for (unsigned int i = 0; i < sizeof(word); i++)
104 |         ss << (int)bytes[i] << " ";
105 |     return ss.str();
106 | }
107 | 
108 | 


--------------------------------------------------------------------------------
/OT/Tools.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef _OTTOOLS
 4 | #define _OTTOOLS
 5 | 
 6 | #include "Networking/Player.h"
 7 | #include "Tools/Commit.h"
 8 | #include "Tools/random.h"
 9 | 
10 | #define SEED_SIZE_BYTES SEED_SIZE
11 | 
12 | /*
13 |  * Generate a secure, random seed between 2 parties via commitment
14 |  */
15 | void random_seed_commit(octet* seed, TwoPartyPlayer& player, int len);
16 | 
17 | /*
18 |  * GF(2^128) multiplication using Intel instructions
19 |  * (should this go in gf2n class???)
20 |  */
21 | void gfmul128(__m128i a, __m128i b, __m128i *res);
22 | void gfred128(__m128i a1, __m128i a2, __m128i *res);
23 | 
24 | //#if defined(__SSE2__)
25 | /*
26 |  * Convert __m128i to string of type T
27 |  */
28 | template <typename T>
29 | string __m128i_toString(const __m128i var) {
30 |     stringstream sstr;
31 |     sstr << hex;
32 |     const T* values = (const T*) &var;
33 |     if (sizeof(T) == 1) {
34 |         for (unsigned int i = 0; i < sizeof(__m128i); i++) {
35 |             sstr << (int) values[i] << " ";
36 |         }
37 |     } else {
38 |         for (unsigned int i = 0; i < sizeof(__m128i) / sizeof(T); i++) {
39 |             sstr << values[i] << " ";
40 |         }
41 |     }
42 |     return sstr.str();
43 | }
44 | //#endif
45 | 
46 | string word_to_bytes(const word w);
47 | 
48 | void shiftl128(word x1, word x2, word& res1, word& res2, size_t k);
49 | 
50 | 
51 | #endif
52 | 


--------------------------------------------------------------------------------
/OT/TripleMachine.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * TripleMachine.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef OT_TRIPLEMACHINE_H_
 9 | #define OT_TRIPLEMACHINE_H_
10 | 
11 | #include "Math/gf2n.h"
12 | #include "Math/gfp.h"
13 | #include "Tools/OfflineMachineBase.h"
14 | 
15 | class TripleMachine : public OfflineMachineBase
16 | {
17 |     gf2n mac_key2;
18 |     gfp mac_keyp;
19 | 
20 | public:
21 |     int nloops;
22 |     string prep_data_dir;
23 |     bool generateMACs;
24 |     bool amplify;
25 |     bool check;
26 |     bool primeField;
27 |     bool bonding;
28 |     bool generateBits;
29 |     struct timeval start, stop;
30 | 
31 |     TripleMachine(int argc, const char** argv);
32 |     void run();
33 | 
34 |     template <class T>
35 |     T get_mac_key();
36 |     void output_mac_keys();
37 | };
38 | 
39 | #endif /* OT_TRIPLEMACHINE_H_ */
40 | 


--------------------------------------------------------------------------------
/Processor/Binary_File_IO.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #include "Processor/Binary_File_IO.h"
 4 | #include "Math/gfp.h"
 5 | 
 6 | /* 
 7 |  * Provides generalised file read and write methods for arrays of shares.
 8 |  * Stateless and not optimised for multiple reads from file.
 9 |  * Intended for application specific file IO.
10 |  */
11 | 
12 | template<class T> 
13 | void Binary_File_IO::write_to_file(const string filename, const vector< Share<T> >& buffer)
14 | {
15 |   ofstream outf;
16 | 
17 |   outf.open(filename, ios::out | ios::binary | ios::app);
18 |   if (outf.fail()) { throw file_error(filename); }
19 | 
20 |   for (unsigned int i = 0; i < buffer.size(); i++)
21 |   {
22 |     buffer[i].output(outf, false);
23 |   }
24 | 
25 |   outf.close();
26 | }
27 | 
28 | template<class T>
29 | void Binary_File_IO::read_from_file(const string filename, vector< Share<T> >& buffer, const int start_posn, int &end_posn)
30 | {
31 |   ifstream inf;
32 |   inf.open(filename, ios::in | ios::binary);
33 |   if (inf.fail()) { throw file_missing(filename, "Binary_File_IO.read_from_file expects this file to exist."); }
34 | 
35 |   int size_in_bytes = Share<T>::size() * buffer.size();
36 |   int n_read = 0;
37 |   char * read_buffer = new char[size_in_bytes];
38 |   inf.seekg(start_posn);
39 |   do
40 |   {
41 |       inf.read(read_buffer + n_read, size_in_bytes - n_read);
42 |       n_read += inf.gcount();
43 | 
44 |       if (inf.eof())
45 |       {
46 |         stringstream ss;
47 |         ss << "Got to EOF when reading from disk (expecting " << size_in_bytes << " bytes).";
48 |         throw file_error(ss.str());
49 |       }
50 |       if (inf.fail())
51 |       {
52 |         stringstream ss;
53 |         ss << "IO problem when reading from disk";
54 |         throw file_error(ss.str());
55 |       }
56 |   }
57 |   while (n_read < size_in_bytes);
58 | 
59 |   end_posn = inf.tellg();
60 | 
61 |   //Check if at end of file by getting 1 more char.
62 |   inf.get();
63 |   if (inf.eof())
64 |     end_posn = -1;
65 |   inf.close();
66 | 
67 |   for (unsigned int i = 0; i < buffer.size(); i++)
68 |     buffer[i].assign(&read_buffer[i*Share<T>::size()]);
69 | }
70 | 
71 | template void Binary_File_IO::write_to_file(const string filename, const vector< Share<gfp> >& buffer);
72 | template void Binary_File_IO::read_from_file(const string filename, vector< Share<gfp> >& buffer, const int start_posn, int &end_posn);
73 | 


--------------------------------------------------------------------------------
/Processor/Binary_File_IO.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef _FILE_IO_HEADER
 4 | #define _FILE_IO_HEADER
 5 | 
 6 | #include "Exceptions/Exceptions.h"
 7 | #include "Math/Share.h"
 8 | 
 9 | #include <string>
10 | #include <sstream>
11 | #include <fstream>
12 | #include <vector>
13 | 
14 | using namespace std;
15 | 
16 | /* 
17 |  * Provides generalised file read and write methods for arrays of numeric data types.
18 |  * Stateless and not optimised for multiple reads from file.
19 |  * Intended for MPC application specific file IO.
20 |  */
21 | 
22 | class Binary_File_IO
23 | {
24 |   public:
25 | 
26 |   /*
27 |    * Append the buffer values as binary to the filename.
28 |    * Throws file_error.   
29 |    */
30 |   template <class T>
31 |   void write_to_file(const string filename, const vector< Share<T> >& buffer);
32 | 
33 |   /*
34 |    * Read from posn in the filename the binary values until the buffer is full.
35 |    * Assumes file holds binary that maps into the type passed in.
36 |    * Returns the current posn in the file or -1 if at eof.
37 |    * Throws file_error.
38 |    */
39 |   template <class T>
40 |   void read_from_file(const string filename, vector< Share<T> >& buffer, const int start_posn, int &end_posn);
41 | };
42 | 
43 | #endif
44 | 


--------------------------------------------------------------------------------
/Processor/Buffer.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * Buffer.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef PROCESSOR_BUFFER_H_
 9 | #define PROCESSOR_BUFFER_H_
10 | 
11 | #include <fstream>
12 | using namespace std;
13 | 
14 | #include "Math/Share.h"
15 | #include "Math/field_types.h"
16 | #include "Tools/time-func.h"
17 | 
18 | #ifndef BUFFER_SIZE
19 | #define BUFFER_SIZE 101
20 | #endif
21 | 
22 | 
23 | class BufferBase
24 | {
25 | protected:
26 |     static bool rewind;
27 | 
28 |     ifstream* file;
29 |     int next;
30 |     const char* data_type;
31 |     const char* field_type;
32 |     Timer timer;
33 |     int tuple_length;
34 |     string filename;
35 | 
36 | public:
37 |     bool eof;
38 | 
39 |     BufferBase() : file(0), next(BUFFER_SIZE), data_type(0), field_type(0),
40 |             tuple_length(-1), eof(false) {}
41 |     void setup(ifstream* f, int length, string filename, const char* type = 0,
42 |             const char* field = 0);
43 |     void seekg(int pos);
44 |     bool is_up() { return file != 0; }
45 |     void try_rewind();
46 |     void prune();
47 |     void purge();
48 | };
49 | 
50 | 
51 | template <class T, class U>
52 | class Buffer : public BufferBase
53 | {
54 |     T buffer[BUFFER_SIZE];
55 | 
56 |     void read(char* read_buffer);
57 | 
58 | public:
59 |     ~Buffer();
60 |     void input(U& a);
61 |     void fill_buffer();
62 | };
63 | 
64 | 
65 | template < template<class T> class U, template<class T> class V >
66 | class BufferHelper
67 | {
68 | public:
69 |     Buffer< U<gfp>, V<gfp> > bufferp;
70 |     Buffer< U<gf2n>, V<gf2n> > buffer2;
71 |     ifstream* files[N_DATA_FIELD_TYPE];
72 | 
73 |     BufferHelper() { memset(files, 0, sizeof(files)); }
74 |     void input(V<gfp>& a) { bufferp.input(a); }
75 |     void input(V<gf2n>& a) { buffer2.input(a); }
76 |     BufferBase& get_buffer(DataFieldType field_type);
77 |     void setup(DataFieldType field_type, string filename, int tuple_length, const char* data_type = 0);
78 |     void close();
79 |     void prune();
80 |     void purge();
81 | };
82 | 
83 | #endif /* PROCESSOR_BUFFER_H_ */
84 | 


--------------------------------------------------------------------------------
/Processor/ExternalClients.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef _ExternalClients
 4 | #define _ExternalClients
 5 | 
 6 | #include "Networking/ServerSocket.h"
 7 | #include "Networking/sockets.h"
 8 | #include "Exceptions/Exceptions.h"
 9 | #include <vector>
10 | #include <map>
11 | #include <iostream>
12 | #include <fstream>
13 | #include <sodium.h>
14 | #include <assert.h>
15 | 
16 | /*
17 |  * Manage the reading and writing of data from/to external clients via Sockets.
18 |  * Generate the session keys for encryption/decryption of secret communication with external clients.
19 |  */
20 | 
21 | class ExternalClients
22 | {
23 |   map<int,AnonymousServerSocket*> client_connection_servers;
24 |   
25 |   int party_num;
26 |   const string prep_data_dir;
27 |   int server_connection_count;  
28 |   unsigned char server_publickey[crypto_box_PUBLICKEYBYTES];
29 |   unsigned char server_secretkey[crypto_box_SECRETKEYBYTES];
30 |   bool server_keys_loaded = false;
31 |   bool ed25519_keys_loaded = false;
32 | 
33 |   public:
34 | 
35 |   unsigned char server_publickey_ed25519[crypto_sign_ed25519_PUBLICKEYBYTES];
36 |   unsigned char server_secretkey_ed25519[crypto_sign_ed25519_SECRETKEYBYTES];
37 | 
38 |   // Maps holding per client values (indexed by unique 32-bit id)
39 |   std::map<int,int> external_client_sockets;
40 |   std::map<int,octet*> symmetric_client_keys;
41 |   std::map<int,pair<vector<octet>,uint64_t>> symmetric_client_commsec_send_keys;
42 |   std::map<int,pair<vector<octet>,uint64_t>> symmetric_client_commsec_recv_keys;
43 | 
44 |   ExternalClients(int party_num, const string& prep_data_dir);
45 |   ~ExternalClients();
46 | 
47 |   void start_listening(int portnum_base);
48 | 
49 |   int get_client_connection(int portnum_base);
50 | 
51 |   int connect_to_server(int portnum_base, int ipv4_address);
52 | 
53 |   // return the socket for a given client or server identifier
54 |   int get_socket(int socket_id);
55 | 
56 |   void curve25519_ints_to_bytes(unsigned char bytes[crypto_box_PUBLICKEYBYTES],  const vector<int>& key_ints);
57 |   void generate_session_key_for_client(int client_id, const vector<int>& public_key);  
58 | 
59 |   void load_server_keys_once();
60 | 
61 |   int get_party_num();
62 |   void require_ed25519_keys();
63 | };
64 | 
65 | #endif
66 | 


--------------------------------------------------------------------------------
/Processor/Input.cpp:
--------------------------------------------------------------------------------
  1 | // (C) 2018 University of Bristol. See License.txt
  2 | 
  3 | /*
  4 |  * Input.cpp
  5 |  *
  6 |  */
  7 | 
  8 | #include "Input.h"
  9 | #include "Processor.h"
 10 | 
 11 | template<class T>
 12 | Input<T>::Input(Processor& proc, MAC_Check<T>& mc) :
 13 |         proc(proc), MC(mc), shares(proc.P.num_players()), values_input(0)
 14 | {
 15 |     buffer.setup(&proc.private_input, -1, proc.private_input_filename);
 16 | }
 17 | 
 18 | template<class T>
 19 | Input<T>::~Input()
 20 | {
 21 |     if (timer.elapsed() > 0)
 22 |         cerr << T::type_string() << " inputs: " << timer.elapsed() << endl;
 23 | }
 24 | 
 25 | template<class T>
 26 | void Input<T>::adjust_mac(Share<T>& share, T& value)
 27 | {
 28 |     T tmp;
 29 |     tmp.mul(MC.get_alphai(), value);
 30 |     tmp.add(share.get_mac(),tmp);
 31 |     share.set_mac(tmp);
 32 | }
 33 | 
 34 | template<class T>
 35 | void Input<T>::start(int player, int n_inputs)
 36 | {
 37 |     shares[player].resize(n_inputs);
 38 |     vector<T> rr(n_inputs);
 39 | 
 40 |     if (player == proc.P.my_num())
 41 |     {
 42 |         octetStream o;
 43 | 
 44 |         for (int i = 0; i < n_inputs; i++)
 45 |         {
 46 |             T rr, t;
 47 |             Share<T>& share = shares[player][i];
 48 |             proc.DataF.get_input(share, rr, player);
 49 |             T xi;
 50 |             try
 51 |             {
 52 |                 buffer.input(t);
 53 |             }
 54 |             catch (not_enough_to_buffer& e)
 55 |             {
 56 |                 throw runtime_error("Insufficient input data to buffer");
 57 |             }
 58 |             t.sub(t, rr);
 59 |             t.pack(o);
 60 |             xi.add(t, share.get_share());
 61 |             share.set_share(xi);
 62 |             adjust_mac(share, t);
 63 |         }
 64 | 
 65 |         proc.P.send_all(o, true);
 66 |         values_input += n_inputs;
 67 |     }
 68 |     else
 69 |     {
 70 |         T t;
 71 |         for (int i = 0; i < n_inputs; i++)
 72 |             proc.DataF.get_input(shares[player][i], t, player);
 73 |     }
 74 | }
 75 | 
 76 | template<class T>
 77 | void Input<T>::stop(int player, vector<int> targets)
 78 | {
 79 |     for (unsigned int i = 0; i < targets.size(); i++)
 80 |         proc.get_S_ref<T>(targets[i]) = shares[player][i];
 81 | 
 82 |     if (proc.P.my_num() != player)
 83 |     {
 84 |         T t;
 85 |         octetStream o;
 86 |         timer.start();
 87 |         proc.P.receive_player(player, o, true);
 88 |         timer.stop();
 89 |         for (unsigned int i = 0; i < targets.size(); i++)
 90 |         {
 91 |             Share<T>& share = proc.get_S_ref<T>(targets[i]);
 92 |             t.unpack(o);
 93 |             adjust_mac(share, t);
 94 |         }
 95 |     }
 96 | }
 97 | 
 98 | template class Input<gf2n>;
 99 | template class Input<gfp>;
100 | 


--------------------------------------------------------------------------------
/Processor/Input.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * Input.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef PROCESSOR_INPUT_H_
 9 | #define PROCESSOR_INPUT_H_
10 | 
11 | #include <vector>
12 | using namespace std;
13 | 
14 | #include "Math/Share.h"
15 | #include "Auth/MAC_Check.h"
16 | #include "Processor/Buffer.h"
17 | #include "Tools/time-func.h"
18 | 
19 | class Processor;
20 | 
21 | template<class T>
22 | class Input
23 | {
24 |     Processor& proc;
25 |     MAC_Check<T>& MC;
26 |     vector< vector< Share<T> > > shares;
27 |     Buffer<T,T> buffer;
28 |     Timer timer;
29 | 
30 |     void adjust_mac(Share<T>& share, T& value);
31 | 
32 | public:
33 |     int values_input;
34 | 
35 |     Input(Processor& proc, MAC_Check<T>& mc);
36 |     ~Input();
37 | 
38 |     void start(int player, int n_inputs);
39 |     void stop(int player, vector<int> targets);
40 | 
41 | };
42 | 
43 | #endif /* PROCESSOR_INPUT_H_ */
44 | 


--------------------------------------------------------------------------------
/Processor/InputTuple.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * InputTuple.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef PROCESSOR_INPUTTUPLE_H_
 9 | #define PROCESSOR_INPUTTUPLE_H_
10 | 
11 | 
12 | template <class T>
13 | struct InputTuple
14 | {
15 |   Share<T> share;
16 |   T value;
17 | 
18 |   static int size()
19 |     { return Share<T>::size() + T::size(); }
20 | 
21 |   static string type_string()
22 |     { return T::type_string(); }
23 | 
24 |   void assign(const char* buffer)
25 |     {
26 |       share.assign(buffer);
27 |       value.assign(buffer + Share<T>::size());
28 |     }
29 | };
30 | 
31 | 
32 | template <class T>
33 | struct RefInputTuple
34 | {
35 |   Share<T>& share;
36 |   T& value;
37 |   RefInputTuple(Share<T>& share, T& value) : share(share), value(value) {}
38 |   void operator=(InputTuple<T>& other) { share = other.share; value = other.value; }
39 | };
40 | 
41 | 
42 | #endif /* PROCESSOR_INPUTTUPLE_H_ */
43 | 


--------------------------------------------------------------------------------
/Processor/Machine.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * Machine.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef MACHINE_H_
 9 | #define MACHINE_H_
10 | 
11 | #include "Processor/Memory.h"
12 | #include "Processor/Program.h"
13 | 
14 | #include "Processor/Online-Thread.h"
15 | #include "Processor/Data_Files.h"
16 | #include "Math/gfp.h"
17 | 
18 | #include "Tools/time-func.h"
19 | 
20 | #include <vector>
21 | #include <map>
22 | using namespace std;
23 | 
24 | class BaseMachine
25 | {
26 | protected:
27 |     std::map<int,Timer> timer;
28 |     void print_timers();
29 | 
30 | public:
31 |     void time();
32 |     void start(int n);
33 |     void stop(int n);
34 | };
35 | 
36 | class Machine : public BaseMachine
37 | {
38 |   /* The mutex's lock the C-threads and then only release
39 |    * then we an MPC thread is ready to run on the C-thread.
40 |    * Control is passed back to the main loop when the
41 |    * MPC thread releases the mutex
42 |    */
43 | 
44 |   vector<thread_info> tinfo;
45 |   vector<pthread_t> threads;
46 | 
47 |   int my_number;
48 |   Names& N;
49 |   gfp  alphapi;
50 |   gf2n alpha2i;
51 | 
52 |   int nthreads;
53 | 
54 |   ifstream inpf;
55 | 
56 |   // Keep record of used offline data
57 |   DataPositions pos;
58 | 
59 |   int tn,numt;
60 |   bool usage_unknown;
61 | 
62 |   public:
63 | 
64 |   vector<pthread_mutex_t> t_mutex;
65 |   vector<pthread_cond_t>  client_ready;
66 |   vector<pthread_cond_t>  server_ready;
67 |   vector<Program>  progs;
68 | 
69 |   Memory<gf2n> M2;
70 |   Memory<gfp> Mp;
71 |   Memory<Integer> Mi;
72 | 
73 |   vector<Timer> join_timer;
74 |   Timer finish_timer;
75 |   
76 |   string prep_dir_prefix;
77 |   string progname;
78 | 
79 |   bool direct;
80 |   int opening_sum;
81 |   bool parallel;
82 |   bool receive_threads;
83 |   int max_broadcast;
84 | 
85 |   Machine(int my_number, Names& playerNames, string progname,
86 |       string memtype, int lgp, int lg2, bool direct, int opening_sum, bool parallel,
87 |       bool receive_threads, int max_broadcast);
88 | 
89 |   DataPositions run_tape(int thread_number, int tape_number, int arg, int line_number);
90 |   void join_tape(int thread_number);
91 |   void run();
92 | };
93 | 
94 | #endif /* MACHINE_H_ */
95 | 


--------------------------------------------------------------------------------
/Processor/Memory.h:
--------------------------------------------------------------------------------
  1 | // (C) 2018 University of Bristol. See License.txt
  2 | 
  3 | #ifndef _Memory
  4 | #define _Memory
  5 | 
  6 | /* Class to hold global memory of our system */
  7 | 
  8 | #include <iostream>
  9 | #include <set>
 10 | using namespace std;
 11 | 
 12 | // Forward declaration as apparently this is needed for friends in templates
 13 | template<class T> class Memory;
 14 | template<class T> ostream& operator<<(ostream& s,const Memory<T>& M);
 15 | template<class T> istream& operator>>(istream& s,Memory<T>& M);
 16 | 
 17 | #include "Processor/Program.h"
 18 | #include "Math/Share.h"
 19 | template<class T> 
 20 | class Memory
 21 | {
 22 |   vector<Share<T> > MS;
 23 |   vector<T> MC;
 24 | #ifdef MEMPROTECT
 25 |   set< pair<unsigned int,unsigned int> > protected_s;
 26 |   set< pair<unsigned int,unsigned int> > protected_c;
 27 | #endif
 28 | 
 29 |   public:
 30 | 
 31 |   void resize_s(int sz)
 32 |     { MS.resize(sz); }
 33 |   void resize_c(int sz)
 34 |     { MC.resize(sz); }
 35 | 
 36 |   int size_s()
 37 |     { return MS.size(); }
 38 |   int size_c()
 39 |     { return MC.size(); }
 40 | 
 41 |   const T& read_C(int i) const
 42 |     { return MC[i]; }
 43 |   const Share<T> & read_S(int i) const
 44 |     { return MS[i]; }
 45 | 
 46 |   void write_C(unsigned int i,const T& x,int PC=-1)
 47 |     { MC[i]=x;
 48 |       (void)PC;
 49 | #ifdef MEMPROTECT
 50 |     if (is_protected_c(i))
 51 |       cerr << "Protected clear memory access of " << i << " by " << PC - 1 << endl;
 52 | #endif
 53 |     }
 54 |   void write_S(unsigned int i,const Share<T> & x,int PC=-1)
 55 |     { MS[i]=x;
 56 |     (void)PC;
 57 | #ifdef MEMPROTECT
 58 |     if (is_protected_s(i))
 59 |       cerr << "Protected secret memory access of " << i << " by " << PC - 1 << endl;
 60 | #endif
 61 |     }
 62 | 
 63 | 
 64 | #ifdef MEMPROTECT
 65 |   void protect_s(unsigned int start, unsigned int end);
 66 |   void protect_c(unsigned int start, unsigned int end);
 67 |   bool is_protected_s(unsigned int index);
 68 |   bool is_protected_c(unsigned int index);
 69 | #else
 70 |   void protect_s(unsigned int start, unsigned int end)
 71 |     { (void)start, (void)end; cerr << "Memory protection not activated" << endl; }
 72 |   void protect_c(unsigned int start, unsigned int end)
 73 |     { (void)start, (void)end; cerr << "Memory protection not activated" << endl; }
 74 | #endif
 75 | 
 76 |   void minimum_size(RegType reg_type, const Program& program, string threadname);
 77 | 
 78 |   friend ostream& operator<< <>(ostream& s,const Memory<T>& M);
 79 |   friend istream& operator>> <>(istream& s,Memory<T>& M);
 80 | 
 81 | };
 82 | 
 83 | 
 84 | /* This function loads a un-shared global memory from disk and
 85 |  * produces the memory
 86 |  *
 87 |  * The global unshared memory is of the form 
 88 |  *     sz     <- Size
 89 |  *    n val   <- Clear values 
 90 |  *    n val   <- Clear values 
 91 |  *    -1 -1   <- End of clear values
 92 |  *    n val   <- Shared values 
 93 |  *    n val   <- Shared values
 94 |  *    -1 -1
 95 |  */
 96 | template<class T>
 97 | void Load_Memory(Memory<T>& M,ifstream& inpf);
 98 | 
 99 | #endif
100 | 
101 | 


--------------------------------------------------------------------------------
/Processor/Online-Thread.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef _Online_Thread
 4 | #define _Online_Thread
 5 | 
 6 | #include "Networking/Player.h"
 7 | #include "Math/gf2n.h"
 8 | #include "Math/gfp.h"
 9 | #include "Math/Integer.h"
10 | #include "Processor/Data_Files.h"
11 | 
12 | #include <vector>
13 | using namespace std;
14 | 
15 | class Machine;
16 | 
17 | class thread_info
18 | {
19 |   public: 
20 | 
21 |   int thread_num;
22 |   int covert;
23 |   Names*  Nms;
24 |   gf2n *alpha2i;
25 |   gfp  *alphapi;
26 |   int prognum;
27 |   bool finished;
28 |   bool ready;
29 | 
30 |   // rownums for triples, bits, squares, and inverses etc
31 |   DataPositions pos;
32 |   // Integer arg (optional)
33 |   int arg;
34 | 
35 |   Machine* machine;
36 | };
37 | 
38 | void* Main_Func(void *ptr);
39 | 
40 | void purge_preprocessing(Names& N, string prep_dir);
41 | 
42 | #endif
43 | 
44 | 


--------------------------------------------------------------------------------
/Processor/PrivateOutput.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * PrivateOutput.cpp
 5 |  *
 6 |  */
 7 | 
 8 | #include "PrivateOutput.h"
 9 | #include "Processor.h"
10 | 
11 | template<class T>
12 | void PrivateOutput<T>::start(int player, int target, int source)
13 | {
14 |     T mask;
15 |     proc.DataF.get_input(proc.get_S_ref<T>(target), mask, player);
16 |     proc.get_S_ref<T>(target).add(proc.get_S_ref<T>(source));
17 | 
18 |     if (player == proc.P.my_num())
19 |         masks.push_back(mask);
20 | }
21 | 
22 | template<class T>
23 | void PrivateOutput<T>::stop(int player, int source)
24 | {
25 |     if (player == proc.P.my_num())
26 |     {
27 |         T value;
28 |         value.sub(proc.get_C_ref<T>(source), masks.front());
29 |         value.output(proc.private_output, false);
30 |         masks.pop_front();
31 |     }
32 | }
33 | 
34 | template class PrivateOutput<gf2n>;
35 | template class PrivateOutput<gfp>;
36 | 


--------------------------------------------------------------------------------
/Processor/PrivateOutput.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * PrivateOutput.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef PROCESSOR_PRIVATEOUTPUT_H_
 9 | #define PROCESSOR_PRIVATEOUTPUT_H_
10 | 
11 | #include <deque>
12 | using namespace std;
13 | 
14 | #include "Math/Share.h"
15 | 
16 | class Processor;
17 | 
18 | template<class T>
19 | class PrivateOutput
20 | {
21 |     Processor& proc;
22 |     deque<T> masks;
23 | 
24 | public:
25 |     PrivateOutput(Processor& proc) : proc(proc) { };
26 | 
27 |     void start(int player, int target, int source);
28 |     void stop(int player, int source);
29 | };
30 | 
31 | #endif /* PROCESSOR_PRIVATEOUTPUT_H_ */
32 | 


--------------------------------------------------------------------------------
/Processor/Program.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | 
 4 | #include "Processor/Program.h"
 5 | #include "Processor/Data_Files.h"
 6 | #include "Processor/Processor.h"
 7 | 
 8 | void Program::compute_constants()
 9 | {
10 |   for (int reg_type = 0; reg_type < MAX_REG_TYPE; reg_type++)
11 |     {
12 |       max_reg[reg_type] = 0;
13 |       for (int sec_type = 0; sec_type < MAX_SECRECY_TYPE; sec_type++)
14 |         max_mem[reg_type][sec_type] = 0;
15 |     }
16 |   for (unsigned int i=0; i<p.size(); i++)
17 |     {
18 |       if (!p[i].get_offline_data_usage(offline_data_used))
19 |         unknown_usage = true;
20 |       for (int reg_type = 0; reg_type < MAX_REG_TYPE; reg_type++)
21 |         {
22 |           max_reg[reg_type] = max(max_reg[reg_type],
23 |               p[i].get_max_reg(reg_type));
24 |           for (int sec_type = 0; sec_type < MAX_SECRECY_TYPE; sec_type++)
25 |             max_mem[reg_type][sec_type] = max(max_mem[reg_type][sec_type],
26 |                 p[i].get_mem(RegType(reg_type), SecrecyType(sec_type)));
27 |         }
28 |     }
29 | }
30 | 
31 | void Program::parse(istream& s)
32 | {
33 |   p.resize(0);
34 |   Instruction instr;
35 |   s.peek();
36 |   while (!s.eof())
37 |     { instr.parse(s);
38 |       p.push_back(instr);
39 |       //cerr << "\t" << instr << endl;
40 |       s.peek();
41 |     }
42 |   compute_constants();
43 | }
44 | 
45 | void Program::print_offline_cost() const
46 | {
47 |   if (unknown_usage)
48 |     {
49 |       cerr << "Tape has unknown usage" << endl;
50 |       return;
51 |     }
52 | 
53 |   cerr << "Cost of first tape:" << endl;
54 |   offline_data_used.print_cost();
55 | }
56 | 
57 | 
58 | ostream& operator<<(ostream& s,const Program& P)
59 | {
60 |   for (unsigned int i=0; i<P.p.size(); i++)
61 |     { s << i << " :: " << P.p[i] << endl; }
62 |   return s;
63 | }
64 | 
65 | 
66 | 
67 | void Program::execute(Processor& Proc) const
68 | {
69 |   unsigned int size = p.size();
70 |   Proc.PC=0;
71 |   octet seed[SEED_SIZE];
72 |   memset(seed, 0, SEED_SIZE);
73 |   Proc.prng.SetSeed(seed);
74 |   while (Proc.PC<size)
75 |     { p[Proc.PC].execute(Proc); }
76 | }
77 | 
78 | 
79 | 
80 | 
81 | 
82 | 
83 | 


--------------------------------------------------------------------------------
/Processor/Program.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef _Program
 4 | #define _Program
 5 | 
 6 | #include "Processor/Instruction.h"
 7 | #include "Processor/Data_Files.h"
 8 | 
 9 | class Machine;
10 | 
11 | /* A program is a vector of instructions */
12 | 
13 | class Program
14 | {
15 |   vector<Instruction> p;
16 |   // Here we note the number of bits, squares and triples and input
17 |   // data needed
18 |   //  - This is computed for a whole program sequence to enable
19 |   //    the run time to be able to determine which ones to pass to it
20 |   DataPositions offline_data_used;
21 | 
22 |   // Maximal register used
23 |   int max_reg[MAX_REG_TYPE];
24 | 
25 |   // Memory size used directly
26 |   int max_mem[MAX_REG_TYPE][MAX_SECRECY_TYPE];
27 | 
28 |   // True if program contains variable-sized loop
29 |   bool unknown_usage;
30 | 
31 |   void compute_constants();
32 | 
33 |   public:
34 | 
35 |   Program(int nplayers) : offline_data_used(nplayers),
36 |       unknown_usage(false)
37 |     { compute_constants(); }
38 | 
39 |   // Read in a program
40 |   void parse(istream& s);
41 | 
42 |   DataPositions get_offline_data_used() const { return offline_data_used; }
43 |   void print_offline_cost() const;
44 | 
45 |   bool usage_unknown() const { return unknown_usage; }
46 | 
47 |   int num_reg(RegType reg_type) const
48 |     { return max_reg[reg_type]; }
49 | 
50 |   const int* direct_mem(RegType reg_type) const
51 |     { return max_mem[reg_type]; }
52 | 
53 |   friend ostream& operator<<(ostream& s,const Program& P);
54 | 
55 |   // Execute this program, updateing the processor and memory
56 |   // and streams pointing to the triples etc
57 |   void execute(Processor& Proc) const;
58 | 
59 | };
60 | 
61 | #endif
62 | 
63 | 


--------------------------------------------------------------------------------
/Programs/Source/dijkstra_tutorial.mpc:
--------------------------------------------------------------------------------
 1 | # (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | import dijkstra
 4 | from path_oram import OptimalORAM
 5 | 
 6 | n = 1000
 7 | 
 8 | dist = dijkstra.test_dijkstra_on_cycle(n, OptimalORAM)
 9 | 
10 | for i in range(n):
11 |     print_ln('%s: %s', i, dist[i][0].reveal())
12 | 


--------------------------------------------------------------------------------
/Programs/Source/fixed_point_tutorial.mpc:
--------------------------------------------------------------------------------
 1 | # (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | program.bit_length = 80
 4 | print "program.bit_length: ", program.bit_length
 5 | program.security = 40
 6 | 
 7 | n = 10
 8 | m = 5
 9 | 
10 | # array of fixed points
11 | A = sfixArray(n)
12 | 
13 | for i in range(n):
14 | 	A[i] = sfix(i)
15 | 
16 | print_ln('array of fixed points')
17 | for i in range(n):
18 | 	print_ln('%s', A[i].reveal())
19 | 
20 | # matrix of fixed points
21 | M = sfixMatrix(n, m)
22 | 
23 | for i in range(n):
24 | 	for j in range(m):
25 | 		M[i][j] = sfix(i*j)
26 | 
27 | print_ln('matrix of fixed points')
28 | for i in range(n):
29 | 	for j in range(m):
30 | 		print_str('%s ', M[i][j].reveal())
31 | 	print_ln(' ')
32 | 
33 | 
34 | # assign scalar to sfix
35 | A[5] = sfix(1.12345)
36 | print_ln('%s', A[5].reveal())
37 | 
38 | AC = Array(n, cfix)
39 | 
40 | for i in range(n):
41 | 	AC[i] = cfix(1.5 * i)
42 | 
43 | for i in range(n):
44 | 	print_ln('%s', AC[i])
45 | 
46 | # assign sint to sfix
47 | s = sint(10)
48 | sa = sfix(); sa.load_int(s)
49 | print_ln('successfully assigned sint to sfix %s', sa.reveal())
50 | 
51 | # division between fixed points
52 | sb = sfix(2.5)
53 | print_ln('division between %s %s = %s', sa.reveal(), sb.reveal(), (sa/sb).reveal())
54 | 
55 | 
56 | 


--------------------------------------------------------------------------------
/Programs/Source/gale-shapley_tutorial.mpc:
--------------------------------------------------------------------------------
1 | # (C) 2018 University of Bristol. See License.txt
2 | 
3 | from Compiler import gs
4 | from Compiler.path_oram import OptimalORAM
5 | 
6 | mm = gs.Matchmaker(50, oram_type=OptimalORAM)
7 | mm.init_hard()
8 | mm.match()
9 | 


--------------------------------------------------------------------------------
/Programs/Source/oram_tutorial.mpc:
--------------------------------------------------------------------------------
1 | # (C) 2018 University of Bristol. See License.txt
2 | 
3 | from path_oram import OptimalORAM
4 | 
5 | array = OptimalORAM(10000)
6 | array[1] = 1
7 | print_ln('%s', array[1].reveal())
8 | 


--------------------------------------------------------------------------------
/Programs/Source/tpmpc_tutorial.mpc:
--------------------------------------------------------------------------------
  1 | # (C) 2018 University of Bristol. See License.txt
  2 | 
  3 | """
  4 | Example programs used in the SPDZ tutorial at the TPMPC 2017 workshop in Bristol.
  5 | """
  6 | 
  7 | from util import if_else
  8 | 
  9 | program.bit_length = 32
 10 | 
 11 | def millionnaires():
 12 | 	""" Secure comparison, receiving input from each party via stdin """
 13 | 	print_ln("Waiting for Alice's input")
 14 | 	alice = sint.get_input_from(0)
 15 | 	print_ln("Waiting for Bob's input")
 16 | 	bob = sint.get_input_from(1)
 17 | 
 18 | 	b = alice < bob
 19 | 	print_ln('The richest is: %s', b.reveal())
 20 | 
 21 | def naive_search(n):
 22 | 	""" Search secret list for private input from Bob """
 23 | 	# hardcoded "secret" list from Alice - in a real application this should be a private input
 24 | 	a = [sint(i) for i in range(n)] 
 25 | 	print_ln("Waiting for search input from Bob")
 26 | 	b = sint.get_input_from(1)
 27 | 
 28 | 	eq_bits = [x == b for x in a]
 29 | 	b_in_a = sum(eq_bits)
 30 | 	print_ln("Is b in Alice's list? %s", b_in_a.reveal())
 31 | 
 32 | def scalable_search(n):
 33 | 	""" Search using SPDZ loop to avoid loop unrolling """
 34 | 	array = Array(n, sint)
 35 | 
 36 | 	@for_range(n)
 37 | 	def _(i):
 38 | 		array[i] = sint(i)
 39 | 
 40 | 	print_ln("Waiting for search input from Bob")
 41 | 	b = sint.get_input_from(1)
 42 | 
 43 | 	# need to use MemValue and Array inside @for_range loops,
 44 | 	# instead of basic sint/cint registers
 45 | 	result = MemValue(sint(0))
 46 | 
 47 | 	@for_range(100, n)
 48 | 	def _(i):
 49 | 		result.write(result + (array[i] == b))
 50 | 
 51 | 	print_ln("Is b in Alice's list? %s", result.reveal())
 52 | 
 53 | def compute_intersection(a, b):
 54 | 	""" Naive quadratic private set intersection.
 55 | 
 56 | 	Returns: secret Array with intersection (padded to len(a)), and
 57 | 	secret Array of bits indicating whether Alice's input matches or not """
 58 | 	n = len(a)
 59 | 	if n != len(b):
 60 | 		raise CompilerError('Inconsistent lengths to compute_intersection')
 61 | 	intersection = Array(n, sint)
 62 | 	is_match_at = Array(n, sint)
 63 | 
 64 | 	@for_range(n)
 65 | 	def _(i):
 66 | 		@for_range(n)
 67 | 		def _(j):
 68 | 			match = a[i] == b[j]
 69 | 			is_match_at[i] += match
 70 | 			intersection[i] = if_else(match, a[i], intersection[i]) # match * a[i] + (1 - match) * intersection[i]
 71 | 	return intersection, is_match_at
 72 | 	
 73 | def set_intersection_example(n):
 74 | 	"""Naive private set intersection on two Arrays, followed by computing the size and average of the intersection"""
 75 | 	a = Array(n, sint)
 76 | 	b = Array(n, sint)
 77 | 	print_ln('Running PSI example')
 78 | 	@for_range(n)
 79 | 	def _(i):
 80 | 		a[i] = i
 81 | 		b[i] = i + 60
 82 | 	intersection, is_match_at = compute_intersection(a,b)
 83 | 
 84 | 	print_ln('Printing set intersection (0: not in intersection)')
 85 | 	size = MemValue(sint(0))
 86 | 	total = MemValue(sint(0))
 87 | 	@for_range(n)
 88 | 	def _(i):
 89 | 		size.write(size + is_match_at[i])
 90 | 		total.write(total + intersection[i])
 91 | 		print_str('%s ', intersection[i].reveal())
 92 | 	print_ln('\nIntersection size: %s', size.reveal())
 93 | 
 94 | 	total_fixed = sfix()
 95 | 	total_fixed.load_int(total.read())
 96 | 	print_ln('Average in intersection: %s', (total_fixed / size.read()).reveal())
 97 | 
 98 | 
 99 | 
100 | millionnaires()
101 | naive_search(100)
102 | scalable_search(10000)
103 | set_intersection_example(100)
104 | 
105 | 


--------------------------------------------------------------------------------
/Programs/Source/tutorial.mpc:
--------------------------------------------------------------------------------
 1 | # (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | def test(actual, expected):
 4 |     if isinstance(actual, (sint, sgf2n)):
 5 |         actual = actual.reveal()
 6 |     print_ln('expected %s, got %s', expected, actual)
 7 | 
 8 | # cint: clear integers modulo p
 9 | # sint: secret integers modulo p
10 | 
11 | a = sint(1)
12 | b = cint(2)
13 | 
14 | test(a + b, 3)
15 | test(a + a, 2)
16 | test(a * b, 2)
17 | test(a * a, 1)
18 | test(a - b, -1)
19 | test(a < b, 1)
20 | test(a <= b, 1)
21 | test(a >= b, 0)
22 | test(a > b, 0)
23 | test(a == b, 0)
24 | test(a != b, 1)
25 | 
26 | clear_a = a.reveal()
27 | 
28 | # sgfn2/cgf2n: secret/clear elements of GF(2^n)
29 | 
30 | a = sgf2n(1)
31 | b = cgf2n(2)
32 | 
33 | test(a + b, 3)
34 | test(a + a, 0)
35 | test(a * b, 2)
36 | test(a * a, 1)
37 | test(a == b, 0)
38 | test(a != b, 1)
39 | 
40 | # arrays and loops
41 | 
42 | a = Array(100, sint)
43 | 
44 | @for_range(100)
45 | def f(i):
46 |     a[i] = sint(i)**2
47 | 
48 | test(a[99], 99**2)
49 | 
50 | # conditional
51 | 
52 | if_then(cint(0))
53 | a[0] = 123
54 | else_then()
55 | a[0] = 789
56 | end_if()
57 | 
58 | test(a[0], 789)
59 | 


--------------------------------------------------------------------------------
/Programs/Source/vickrey.mpc:
--------------------------------------------------------------------------------
 1 | # (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | import util
 4 | from Compiler import types
 5 | 
 6 | import math
 7 | import re
 8 | r = re.search('(\D*)(\d*)', program.name)
 9 | 
10 | if r.group(2):
11 |     n_inputs = int(r.group(2))
12 | else:
13 |     n_inputs = 100
14 | 
15 | n_parties = 2
16 | n_threads = int(math.ceil(2 ** (int(math.log(n_inputs, 2) - 7))))
17 | n_loops = 1
18 | n_bits = 64
19 | #value_type = types.get_sgf2nuint(n_bits)
20 | value_type = sint
21 | 
22 | program.set_bit_length(n_bits)
23 | program.set_security(40)
24 | 
25 | print_ln('n_inputs = %s, n_parties = %s, n_threads = %s, n_loops = %s, '
26 |          'value_type = %s',
27 |          n_inputs, n_parties, n_threads, n_loops, value_type.__name__)
28 | 
29 | @for_range(n_loops)
30 | def f(_):
31 |     Bid = types.getNamedTupleType('party', 'price')
32 |     bids = Bid.get_array(n_inputs, value_type)
33 | 
34 |     for i in range(n_inputs):
35 |         # i * 10 because inputs are all zero by default
36 |         bids[i] = Bid(i, value_type.get_raw_input_from(i % n_parties) + i * 10)
37 |         #bids = [Bid(i, value_type(i * 10)) for i in range(n_parties)]
38 | 
39 |     def bid_sort(a, b):
40 |         comp = a.price < b.price
41 |         res = util.cond_swap(comp, a, b)
42 |         for i in res:
43 |             i.price = value_type.hard_conv(i.price)
44 |         return res
45 | 
46 |     def first_and_second(left, right):
47 |         top = left[0].price < right[0].price
48 |         cross = [left[i].price < right[1-i].price for i in range(2)]
49 |         first = top.if_else(right[0], left[0])
50 |         tmp = [cross[i].if_else(right[1-i], left[i]) for i in (0,1)]
51 |         second = top.if_else(*tmp)
52 |         for i in (first, second):
53 |             i.price = value_type.hard_conv(i.price)
54 |         return first, second
55 | 
56 |     results = Bid.get_array(2 * n_threads, value_type)
57 | 
58 |     def thread():
59 |         i = get_arg()
60 |         n_per_thread = n_inputs / n_threads
61 |         if n_per_thread % 2 != 0:
62 |             raise Exception('Number of inputs must be divisible by 2')
63 |         start = i * n_per_thread
64 |         tuples = [bid_sort(bids[start+2*j], bids[start+2*j+1]) \
65 |                   for j in range(n_per_thread / 2)]
66 |         first, second = util.tree_reduce(first_and_second, tuples)
67 |         results[2*i], results[2*i+1] = first, second
68 | 
69 |     tape = program.new_tape(thread)
70 |     threads = [program.run_tape(tape, i) for i in range(n_threads)]
71 |     for i in threads:
72 |         program.join_tape(i)
73 | 
74 |     tuples = [(results[2*i], results[2*i+1]) for i in range(n_threads)]
75 |     first, second = util.tree_reduce(first_and_second, tuples)
76 | 
77 |     print_ln('Winner: %s, price: %s', first.party.reveal(), second.price.reveal())
78 | 


--------------------------------------------------------------------------------
/Scripts/gen_input_f2n.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #include <iostream>
 4 | #include <fstream>
 5 | #include "Math/gf2n.h"
 6 | #include "Processor/Buffer.h"
 7 | 
 8 | using namespace std;
 9 | 
10 | int main() {
11 | 	ifstream cin("gf2n_vals.in");
12 | 	ofstream cout("gf2n_vals.out");
13 | 
14 | 	gf2n::init_field(40);
15 | 
16 | 	int n; cin >> n;
17 | 	for (int i = 0; i < n; ++i) {
18 | 		gf2n_short x; cin >> x;
19 | 		cerr << "value is: " << x << "\n";
20 | 		x.output(cout,false);
21 | 	}
22 | 	n = -(n % BUFFER_SIZE) + BUFFER_SIZE;
23 | 	cerr << "Adding " << n << " zeros to match buffer size" << endl;
24 | 	for (int i = 0; i < n; i++)
25 | 		gf2n(0).output(cout, false);
26 | 
27 | 	cin.close();
28 | 	cout.close();
29 | 	return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/Scripts/run-common.sh:
--------------------------------------------------------------------------------
 1 | # (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | 
 4 | run_player() {
 5 |     port=$((RANDOM%10000+10000))
 6 |     bin=$1
 7 |     shift
 8 |     if ! test -e $SPDZROOT/logs; then
 9 |         mkdir $SPDZROOT/logs
10 |     fi
11 |     if test $bin = Player-Online.x; then
12 | 	params="$* -pn $port -h localhost"
13 |     else
14 | 	params="$port localhost $*"
15 |     fi
16 |     if test $bin = Player-KeyGen.x -a ! -e Player-Data/Params-Data; then
17 | 	./Setup.x $players $size 40
18 |     fi
19 |     >&2 echo Running $SPDZROOT/Server.x $players $port
20 |     $SPDZROOT/Server.x $players $port &
21 |     rem=$(($players - 2))
22 |     for i in $(seq 0 $rem); do
23 |       echo "trying with player $i"
24 |       >&2 echo Running $prefix $SPDZROOT/$bin $i $params
25 |       $prefix $SPDZROOT/$bin $i $params 2>&1 | tee $SPDZROOT/logs/$i &
26 |     done
27 |     last_player=$(($players - 1))
28 |     >&2 echo Running $prefix $SPDZROOT/$bin $last_player $params
29 |     $prefix $SPDZROOT/$bin $last_player $params > $SPDZROOT/logs/$last_player 2>&1 || return 1
30 | }
31 | 
32 | killall Player-Online.x Server.x
33 | sleep 0.5
34 | 
35 | #mkdir /dev/shm/Player-Data
36 | 
37 | players=${PLAYERS:-2}
38 | 
39 | SPDZROOT=${SPDZROOT:-.}
40 | 
41 | #. Scripts/setup.sh
42 | 
43 | mkdir logs
44 | 


--------------------------------------------------------------------------------
/Scripts/run-online.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # (C) 2018 University of Bristol. See License.txt
 4 | 
 5 | HERE=$(cd `dirname $0`; pwd)
 6 | SPDZROOT=$HERE/..
 7 | 
 8 | bits=${2:-128}
 9 | g=${3:-0}
10 | mem=${4:-empty}
11 | 
12 | . $HERE/run-common.sh
13 | 
14 | run_player Player-Online.x ${1:-test_all} -lgp ${bits} -lg2 ${g} -m ${mem} || exit 1
15 | 


--------------------------------------------------------------------------------
/Scripts/setup-online.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # (C) 2018 University of Bristol. See License.txt
 4 | 
 5 | HERE=$(cd `dirname $0`; pwd)
 6 | SPDZROOT=$HERE/..
 7 | 
 8 | # number of players
 9 | players=${1:-2}
10 | # prime field bit length
11 | bits=${2:-128}
12 | # binary field bit length, default by binary
13 | g=${3:-0}
14 | # default number of triples etc. to create
15 | default=${4:-10000}
16 | 
17 | die () {
18 |     echo >&2 "$@"
19 |     echo >&2 "Usage:
20 | setup-online.sh [nplayers] [prime_bitlength] [gf2n_bitlength] [num_prep]
21 | Defaults:
22 | nplayers=2, prime_bitlength=128, gf2n_bitlength=40/128 (as compiled), num_prep=10000"
23 |     exit 1
24 | }
25 | 
26 | [ "$#" -le 4 ] || die "More than 4 arguments provided"
27 | 
28 | for arg in "$@"
29 | do
30 |     echo "$arg" | grep -E -q '^[0-9]+$' || die "Integer argument required, $arg provided"
31 | done
32 | 
33 | $SPDZROOT/Fake-Offline.x ${players} -lgp ${bits} -lg2 ${g} --default ${default}
34 | 
35 | for i in $(seq 0 $[players-1]) ; do
36 |     dd if=/dev/zero of=Player-Data/Private-Input-$i bs=10000 count=1
37 | done
38 | 


--------------------------------------------------------------------------------
/Server.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * Server.cpp
 5 |  *
 6 |  */
 7 | 
 8 | #include "Networking/Server.h"
 9 | 
10 | int main(int argc, char** argv)
11 | {
12 |     Server(argc, argv).start();
13 | }
14 | 


--------------------------------------------------------------------------------
/Tools/Commit.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | 
 4 | #include "Commit.h"
 5 | #include "random.h"
 6 | #include "int.h"
 7 | 
 8 | void Commit(octetStream& comm,octetStream& open,const octetStream& message, int send_player)
 9 | {
10 |     open.store(send_player);
11 |     open.append(message.get_data(), message.get_length());
12 |     open.append_random(SEED_SIZE);
13 |     comm = open.hash();
14 | }
15 | 
16 | bool Open(octetStream& message,const octetStream& comm,const octetStream& open, int send_player)
17 | {
18 |     octetStream h = open.hash();
19 |     octet* open_bytes = open.get_data();
20 |     // first 4 bytes are player no.
21 |     int open_player = BYTES_TO_INT(open_bytes);
22 |     if (!(h.equals(comm) && open_player == send_player))
23 |     {
24 |         return false;
25 |     }
26 |     message.reset_write_head();
27 |     message.append(open_bytes + sizeof(int), open.get_length() - SEED_SIZE - sizeof(int));
28 |     return true;
29 | }
30 | 
31 | void Commitment::commit(const octetStream& message)
32 | {
33 |     open.reset_write_head();
34 |     open.append_random(SEED_SIZE);
35 |     commit(message, open);
36 | }
37 | 
38 | void Commitment::commit(const octetStream& message, const octetStream& open)
39 | {
40 |     SHA1 hash;
41 |     hash.update(&send_player, sizeof(send_player));
42 |     hash.update(message);
43 |     hash.update(open);
44 |     hash.final(comm);
45 | }
46 | 
47 | void Commitment::check(const octetStream& message, const octetStream& comm,
48 |         const octetStream& open)
49 | {
50 |     commit(message, open);
51 |     if (!(comm == this->comm))
52 |         throw invalid_commitment();
53 | }
54 | 
55 | void AllCommitments::commit_and_open(const octetStream& message)
56 | {
57 |     Commitment mine(P.my_num());
58 |     mine.commit(message);
59 |     comms[P.my_num()] = mine.comm;
60 |     opens[P.my_num()] = mine.open;
61 |     P.Broadcast_Receive(comms);
62 |     P.Broadcast_Receive(opens);
63 | }
64 | 
65 | void AllCommitments::check(int player, const octetStream& message)
66 | {
67 |     Commitment(player).check(message, comms[player], opens[player]);
68 | }
69 | 
70 | void AllCommitments::check_relative(int diff, const octetStream& message)
71 | {
72 |     check((P.my_num() + P.num_players() - diff) % P.num_players(), message);
73 | }
74 | 


--------------------------------------------------------------------------------
/Tools/Commit.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef _Commit
 4 | #define _Commit
 5 | 
 6 | /* Define the hash based commitment scheme */
 7 | 
 8 | #include "Tools/octetStream.h"
 9 | #include "Networking/Player.h"
10 | 
11 | /*
12 |  * Commit using comm = hash(send_player || message || r)
13 |  * where r is SEED_SIZE random bytes
14 |  */
15 | void Commit(octetStream& comm, octetStream& open, const octetStream& message, int send_player);
16 | 
17 | bool Open(octetStream& message, const octetStream& comm, const octetStream& open, int send_player);
18 | 
19 | // same as above using less memory
20 | class Commitment
21 | {
22 |     int send_player;
23 | 
24 | public:
25 |     // open only contains the randomness
26 |     octetStream comm, open;
27 | 
28 |     Commitment(int send_player) : send_player(send_player) {}
29 |     void commit(const octetStream& message);
30 |     void commit(const octetStream& message, const octetStream& open);
31 |     void check(const octetStream& message, const octetStream& comm,
32 |             const octetStream& open);
33 | };
34 | 
35 | class AllCommitments
36 | {
37 |     const Player& P;
38 |     vector<octetStream> comms, opens;
39 | 
40 | public:
41 |     AllCommitments(const Player& P) : P(P), comms(P.num_players()), opens(P.num_players()) {}
42 |     // no checks yet
43 |     void commit_and_open(const octetStream& message);
44 |     void check(int player, const octetStream& message);
45 |     void check_relative(int diff, const octetStream& message);
46 | };
47 | 
48 | #endif
49 | 
50 | 


--------------------------------------------------------------------------------
/Tools/Config.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #include "Tools/octetStream.h"
 4 | #include "Networking/Player.h"
 5 | #include <sodium.h>
 6 | namespace Config {
 7 |     typedef vector<octet> public_key;
 8 |     typedef vector<octet> public_signing_key;
 9 |     typedef vector<octet> secret_key;
10 |     typedef vector<octet> secret_signing_key;
11 |     void read_player_config(string cfgdir,int my_number,vector<public_signing_key> pubkeys,secret_signing_key mysecretkey, public_signing_key mypubkey);
12 |     void write_player_config_file(string config_dir
13 |                            ,int player_number, public_key my_pub, secret_key my_priv
14 |                                              , public_signing_key my_signing_pub, secret_signing_key my_signing_priv
15 |                                              , vector<public_key> client_pubs, vector<public_signing_key> client_signing_pubs
16 |                                              , vector<public_key> player_pubs, vector<public_signing_key> player_signing_pubs);
17 |     uint64_t getW64le(ifstream &infile);
18 |     void putW64le(ofstream &outf, uint64_t nr);
19 |     extern const string default_player_config_file_prefix;
20 |     string player_config_file(int player_number);
21 |     void print_vector(const vector<octet> &vec);
22 | }
23 | 


--------------------------------------------------------------------------------
/Tools/Lock.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * Lock.cpp
 5 |  *
 6 |  */
 7 | 
 8 | #include <Tools/Lock.h>
 9 | 
10 | Lock::Lock()
11 | {
12 |     pthread_mutex_init(&mutex, 0);
13 | }
14 | 
15 | Lock::~Lock()
16 | {
17 |     pthread_mutex_destroy(&mutex);
18 | }
19 | 
20 | void Lock::lock()
21 | {
22 |     pthread_mutex_lock(&mutex);
23 | }
24 | 
25 | void Lock::unlock()
26 | {
27 |     pthread_mutex_unlock(&mutex);
28 | }
29 | 


--------------------------------------------------------------------------------
/Tools/Lock.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * Lock.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef TOOLS_LOCK_H_
 9 | #define TOOLS_LOCK_H_
10 | 
11 | #include <pthread.h>
12 | 
13 | class Lock
14 | {
15 |     pthread_mutex_t mutex;
16 | public:
17 |     Lock();
18 |     virtual ~Lock();
19 | 
20 |     void lock();
21 |     void unlock();
22 | };
23 | 
24 | #endif /* TOOLS_LOCK_H_ */
25 | 


--------------------------------------------------------------------------------
/Tools/MMO.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * MMO.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef TOOLS_MMO_H_
 9 | #define TOOLS_MMO_H_
10 | 
11 | #include "Tools/aes.h"
12 | 
13 | // Matyas-Meyer-Oseas hashing
14 | class MMO
15 | {
16 |     octet IV[176]  __attribute__((aligned (16)));
17 | 
18 |     template<int N>
19 |     static void encrypt_and_xor(void* output, const void* input,
20 |             const octet* key);
21 |     template<int N>
22 |     static void encrypt_and_xor(void* output, const void* input,
23 |             const octet* key, const int* indices);
24 | 
25 | public:
26 |     MMO() { zeroIV(); }
27 |     void zeroIV();
28 |     void setIV(octet key[AES_BLK_SIZE]);
29 |     template <class T>
30 |     void hashOneBlock(octet* output, octet* input);
31 |     template <class T, int N>
32 |     void hashBlockWise(octet* output, octet* input);
33 |     template <class T>
34 |     void outputOneBlock(octet* output);
35 | };
36 | 
37 | #endif /* TOOLS_MMO_H_ */
38 | 


--------------------------------------------------------------------------------
/Tools/MemoryUsage.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * MemoryUsage.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef TOOLS_MEMORYUSAGE_H_
 9 | #define TOOLS_MEMORYUSAGE_H_
10 | 
11 | #include <map>
12 | using namespace std;
13 | 
14 | class MemoryUsage
15 | {
16 |     map<string, size_t> usage;
17 | 
18 | public:
19 |     MemoryUsage& operator+=(const MemoryUsage& other)
20 |     {
21 |         for (auto& it : other.usage)
22 |             usage[it.first] += it.second;
23 |         return *this;
24 |     }
25 | 
26 |     void update(const string& tag, size_t size)
27 |     {
28 |         usage[tag] = max(size, usage[tag]);
29 |     }
30 | 
31 |     void add(const string& tag, size_t size)
32 |     {
33 |         usage[tag] += size;
34 |     }
35 | 
36 |     size_t get(const string& tag)
37 |     {
38 |         return usage[tag];
39 |     }
40 | 
41 |     void print()
42 |     {
43 |         for (auto& it : usage)
44 |             cout << it.first << " required: " << 1e-9 * it.second << " (GB)" << endl;
45 |     }
46 | };
47 | 
48 | #endif /* TOOLS_MEMORYUSAGE_H_ */
49 | 


--------------------------------------------------------------------------------
/Tools/OfflineMachineBase.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * OfflineMachineBase.cpp
 5 |  *
 6 |  */
 7 | 
 8 | #include <Tools/OfflineMachineBase.h>
 9 | #include "Tools/int.h"
10 | 
11 | #include <string>
12 | using namespace std;
13 | 
14 | 
15 | OfflineMachineBase::OfflineMachineBase() :
16 |         server(0), my_num(0), nplayers(0), nthreads(0), ntriples(0),
17 |         nTriplesPerThread(0), output(0)
18 | {
19 | }
20 | 
21 | OfflineMachineBase::~OfflineMachineBase()
22 | {
23 |     if (server)
24 |         delete server;
25 | }
26 | 
27 | void OfflineMachineBase::parse_options(int argc, const char** argv)
28 | {
29 |     opt.add(
30 |         "2", // Default.
31 |         0, // Required?
32 |         1, // Number of args expected.
33 |         0, // Delimiter if expecting multiple args.
34 |         "Number of parties (default: 2).", // Help description.
35 |         "-N", // Flag token.
36 |         "--nparties" // Flag token.
37 |     );
38 |     opt.add(
39 |         "", // Default.
40 |         1, // Required?
41 |         1, // Number of args expected.
42 |         0, // Delimiter if expecting multiple args.
43 |         "This player's number, 0/1 (required).", // Help description.
44 |         "-p", // Flag token.
45 |         "--player" // Flag token.
46 |     );
47 |     opt.add(
48 |         "1",
49 |         0,
50 |         1,
51 |         0,
52 |         "Number of threads (default: 1).",
53 |         "-x",
54 |         "--nthreads"
55 |     );
56 |     opt.add(
57 |         "1000", // Default.
58 |         0, // Required?
59 |         1, // Number of args expected.
60 |         0, // Delimiter if expecting multiple args.
61 |         "Number of triples (default: 1000).", // Help description.
62 |         "-n", // Flag token.
63 |         "--ntriples" // Flag token.
64 |     );
65 |     opt.add(
66 |         "", // Default.
67 |         0, // Required?
68 |         0, // Number of args expected.
69 |         0, // Delimiter if expecting multiple args.
70 |         "Write results to files.", // Help description.
71 |         "-o", // Flag token.
72 |         "--output" // Flag token.
73 |     );
74 | 
75 |     opt.parse(argc, argv);
76 |     if (!opt.isSet("-p"))
77 |     {
78 |         string usage;
79 |         opt.getUsage(usage);
80 |         cout << usage;
81 |         exit(0);
82 |     }
83 | 
84 |     opt.get("-p")->getInt(my_num);
85 |     opt.get("-N")->getInt(nplayers);
86 |     opt.get("-x")->getInt(nthreads);
87 |     opt.get("-n")->getLongLong(ntriples);
88 |     output = opt.get("-o")->isSet;
89 | 
90 |     nTriplesPerThread =  DIV_CEIL(ntriples, nthreads);
91 | }
92 | 
93 | void OfflineMachineBase::start_networking_with_server(string hostname,
94 |         int portnum)
95 | {
96 |     server = Server::start_networking(N, my_num, nplayers, hostname, portnum);
97 | }
98 | 


--------------------------------------------------------------------------------
/Tools/OfflineMachineBase.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * OfflineMachineBase.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef TOOLS_OFFLINEMACHINEBASE_H_
 9 | #define TOOLS_OFFLINEMACHINEBASE_H_
10 | 
11 | #include "Tools/ezOptionParser.h"
12 | #include "Networking/Server.h"
13 | #include "Networking/Player.h"
14 | 
15 | class OfflineMachineBase
16 | {
17 | protected:
18 |     ez::ezOptionParser opt;
19 |     Server* server;
20 | 
21 | public:
22 |     Names N;
23 |     int my_num, nplayers, nthreads;
24 |     long long ntriples, nTriplesPerThread;
25 |     bool output;
26 | 
27 |     OfflineMachineBase();
28 |     ~OfflineMachineBase();
29 | 
30 |     void parse_options(int argc, const char** argv);
31 |     void start_networking_with_server(string hostname = "localhost", int portnum = 5000);
32 | };
33 | 
34 | #endif /* TOOLS_OFFLINEMACHINEBASE_H_ */
35 | 


--------------------------------------------------------------------------------
/Tools/Signal.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * Signal.cpp
 5 |  *
 6 |  */
 7 | 
 8 | #include "Signal.h"
 9 | 
10 | Signal::Signal()
11 | {
12 |     pthread_mutex_init(&mutex, 0);
13 |     pthread_cond_init(&cond, 0);
14 | }
15 | 
16 | Signal::~Signal()
17 | {
18 |     pthread_mutex_destroy(&mutex);
19 |     pthread_cond_destroy(&cond);
20 | }
21 | 
22 | void Signal::lock()
23 | {
24 |     pthread_mutex_lock(&mutex);
25 | }
26 | 
27 | void Signal::unlock()
28 | {
29 |     pthread_mutex_unlock(&mutex);
30 | }
31 | 
32 | void Signal::wait()
33 | {
34 |     pthread_cond_wait(&cond, &mutex);
35 | }
36 | 
37 | int Signal::wait(int seconds)
38 | {
39 |     timespec ts;
40 |     clock_gettime(CLOCK_REALTIME, &ts);
41 |     ts.tv_sec += seconds;
42 |     return pthread_cond_timedwait(&cond, &mutex, &ts);
43 | }
44 | 
45 | void Signal::broadcast()
46 | {
47 |     pthread_cond_broadcast(&cond);
48 | }
49 | 


--------------------------------------------------------------------------------
/Tools/Signal.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * Signal.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef TOOLS_SIGNAL_H_
 9 | #define TOOLS_SIGNAL_H_
10 | 
11 | #include <pthread.h>
12 | 
13 | class Signal
14 | {
15 |     pthread_mutex_t mutex;
16 |     pthread_cond_t cond;
17 | 
18 | public:
19 |     Signal();
20 |     virtual ~Signal();
21 |     void lock();
22 |     void unlock();
23 |     void wait();
24 |     int wait(int seconds);
25 |     void broadcast();
26 | };
27 | 
28 | #endif /* TOOLS_SIGNAL_H_ */
29 | 


--------------------------------------------------------------------------------
/Tools/WaitQueue.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * WaitQueue.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef TOOLS_WAITQUEUE_H_
 9 | #define TOOLS_WAITQUEUE_H_
10 | 
11 | #include <pthread.h>
12 | #include <deque>
13 | using namespace std;
14 | 
15 | template<class T>
16 | class WaitQueue
17 | {
18 |     pthread_mutex_t mutex;
19 |     pthread_cond_t cond;
20 | 
21 |     deque<T> queue;
22 |     bool running;
23 | 
24 |     // prevent copying
25 |     WaitQueue(const WaitQueue& other);
26 | 
27 | public:
28 |     WaitQueue() : running(true)
29 |     {
30 |         pthread_mutex_init(&mutex, 0);
31 |         pthread_cond_init(&cond, 0);
32 |     }
33 | 
34 |     ~WaitQueue()
35 |     {
36 |         pthread_mutex_destroy(&mutex);
37 |         pthread_cond_destroy(&cond);
38 |     }
39 | 
40 |     void lock()
41 |     {
42 |         pthread_mutex_lock(&mutex);
43 |     }
44 | 
45 |     void unlock()
46 |     {
47 |         pthread_mutex_unlock(&mutex);
48 |     }
49 | 
50 |     void wait()
51 |     {
52 |         pthread_cond_wait(&cond, &mutex);
53 |     }
54 | 
55 |     void signal()
56 |     {
57 |         pthread_cond_signal(&cond);
58 |     }
59 | 
60 |     void push(const T& value)
61 |     {
62 |         lock();
63 |         queue.push_back(value);
64 |         signal();
65 |         unlock();
66 |     }
67 | 
68 |     bool pop(T& value)
69 |     {
70 |         lock();
71 |         if (running and queue.size() == 0)
72 |             wait();
73 |         if (running)
74 |         {
75 |             value = queue.front();
76 |             queue.pop_front();
77 |         }
78 |         unlock();
79 |         return running;
80 |     }
81 | 
82 |     void stop()
83 |     {
84 |         lock();
85 |         running = false;
86 |         signal();
87 |         unlock();
88 |     }
89 | };
90 | 
91 | #endif /* TOOLS_WAITQUEUE_H_ */
92 | 


--------------------------------------------------------------------------------
/Tools/avx_memcpy.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * memcpy.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef TOOLS_AVX_MEMCPY_H_
 9 | #define TOOLS_AVX_MEMCPY_H_
10 | 
11 | #include <immintrin.h>
12 | #include <string.h>
13 | 
14 | inline void avx_memcpy(void* dest, const void* source, size_t length)
15 | {
16 | 	__m256i* d = (__m256i*)dest, *s = (__m256i*)source;
17 | #ifdef __AVX__
18 | 	while (length >= 32)
19 | 	{
20 | 		_mm256_storeu_si256(d++, _mm256_loadu_si256(s++));
21 | 		length -= 32;
22 | 	}
23 | #endif
24 | 	__m128i* d2 = (__m128i*)d;
25 | 	__m128i* s2 = (__m128i*)s;
26 | 	while (length >= 16)
27 | 	{
28 | 		_mm_storeu_si128(d2++, _mm_loadu_si128(s2++));
29 | 		length -= 16;
30 | 	}
31 | 	if (length)
32 | 		memcpy(d2, s2, length);
33 | }
34 | 
35 | inline void avx_memzero(void* dest, size_t length)
36 | {
37 | 	__m256i* d = (__m256i*)dest;
38 | #ifdef __AVX__
39 | 	__m256i s = _mm256_setzero_si256();
40 | 	while (length >= 32)
41 | 	{
42 | 		_mm256_storeu_si256(d++, s);
43 | 		length -= 32;
44 | 	}
45 | #endif
46 | 	if (length)
47 | 		memset((void*)d, 0, length);
48 | }
49 | 
50 | #endif /* TOOLS_AVX_MEMCPY_H_ */
51 | 


--------------------------------------------------------------------------------
/Tools/benchmarking.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * benchmarking.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef TOOLS_BENCHMARKING_H_
 9 | #define TOOLS_BENCHMARKING_H_
10 | 
11 | #include <stdexcept>
12 | 
13 | // call before insecure benchmarking functionality
14 | inline void insecure(string message, bool warning = true)
15 | {
16 | #ifdef INSECURE
17 |     if (warning)
18 |         cerr << "WARNING: insecure " << message << endl;
19 | #else
20 |     (void)warning;
21 |     string msg = "You are trying to use insecure benchmarking functionality for "
22 |             + message + ".\nYou can activate this at compile time "
23 |                     "by adding -DINSECURE to the compiler options.\n"
24 |                     "Make sure to run make clean as well.";
25 |     throw runtime_error(msg);
26 | #endif
27 | }
28 | 
29 | #endif /* TOOLS_BENCHMARKING_H_ */
30 | 


--------------------------------------------------------------------------------
/Tools/ezOptionParser-MIT-LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (C) 2011,2012 Remik Ziemlinski
2 | 
3 | 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:
4 | 
5 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
6 | 
7 | 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.
8 | 


--------------------------------------------------------------------------------
/Tools/int.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * int.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef TOOLS_INT_H_
 9 | #define TOOLS_INT_H_
10 | 
11 | 
12 | typedef unsigned char octet;
13 | 
14 | // Assumes word is a 64 bit value
15 | #ifdef WIN32
16 |   typedef unsigned __int64 word;
17 | #else
18 |   typedef unsigned long word;
19 | #endif
20 | 
21 | 
22 | inline int CEIL_LOG2(int x)
23 | {
24 |     int result = 0;
25 |     x--;
26 |     while (x > 0)
27 |     {
28 |         result++;
29 |         x >>= 1;
30 |     }
31 |     return result;
32 | }
33 | 
34 | inline int FLOOR_LOG2(int x)
35 | {
36 |     int result = 0;
37 |     while (x > 1)
38 |     {
39 |         result++;
40 |         x >>= 1;
41 |     }
42 |     return result;
43 | }
44 | 
45 | // ceil(n / k)
46 | inline long long DIV_CEIL(long long n, long long k)
47 | {
48 |     return (n + k - 1)/k;
49 | }
50 | 
51 | inline void INT_TO_BYTES(octet *buff, int x)
52 | {
53 |     buff[0] = x&255;
54 |     buff[1] = (x>>8)&255;
55 |     buff[2] = (x>>16)&255;
56 |     buff[3] = (x>>24)&255;
57 | }
58 | 
59 | inline int BYTES_TO_INT(octet *buff)
60 | {
61 |     return buff[0] + 256*buff[1] + 65536*buff[2] + 16777216*buff[3];
62 | }
63 | 
64 | inline int positive_modulo(int i, int n) {
65 |     return (i % n + n) % n;
66 | }
67 | 
68 | #endif /* TOOLS_INT_H_ */
69 | 


--------------------------------------------------------------------------------
/Tools/mkpath.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #include "Tools/mkpath.h"
 4 | #include <string.h>
 5 | #include <limits.h>     /* PATH_MAX */
 6 | #include <sys/stat.h>   /* mkdir(2) */
 7 | #include <errno.h>
 8 | 
 9 | // mkdir -p, from https://gist.github.com/JonathonReinhart/8c0d90191c38af2dcadb102c4e202950
10 | int mkdir_p(const char *path)
11 | {
12 |     /* Adapted from http://stackoverflow.com/a/2336245/119527 */
13 |     const size_t len = strlen(path);
14 |     char _path[PATH_MAX];
15 |     char *p; 
16 | 
17 |     errno = 0;
18 | 
19 |     /* Copy string so its mutable */
20 |     if (len > sizeof(_path)-1) {
21 |         errno = ENAMETOOLONG;
22 |         return -1; 
23 |     }   
24 |     strcpy(_path, path);
25 | 
26 |     /* Iterate the string */
27 |     for (p = _path + 1; *p; p++) {
28 |         if (*p == '/') {
29 |             /* Temporarily truncate */
30 |             *p = '\0';
31 | 
32 |             if (mkdir(_path, S_IRWXU) != 0) {
33 |                 if (errno != EEXIST)
34 |                     return -1; 
35 |             }
36 | 
37 |             *p = '/';
38 |         }
39 |     }   
40 | 
41 |     if (mkdir(_path, S_IRWXU) != 0) {
42 |         if (errno != EEXIST)
43 |             return -1; 
44 |     }   
45 | 
46 |     return 0;
47 | }


--------------------------------------------------------------------------------
/Tools/mkpath.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef TOOLS_MKPATH_H_
 4 | #define TOOLS_MKPATH_H_
 5 | 
 6 | // mkdir -p, from https://gist.github.com/JonathonReinhart/8c0d90191c38af2dcadb102c4e202950
 7 | int mkdir_p(const char *path);
 8 | 
 9 | #endif /* TOOLS_MKPATH_H_ */
10 | 


--------------------------------------------------------------------------------
/Tools/names.cpp:
--------------------------------------------------------------------------------
1 | // (C) 2018 University of Bristol. See License.txt
2 | 
3 | #include "Processor/Data_Files.h"
4 | 
5 | const char* Data_Files::dtype_names[N_DTYPE] = { "Triples", "Squares", "Bits", "Inverses", "BitTriples", "BitGF2NTriples" };
6 | 


--------------------------------------------------------------------------------
/Tools/parse.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * parse.h
 5 |  *
 6 |  */
 7 | 
 8 | #ifndef TOOLS_PARSE_H_
 9 | #define TOOLS_PARSE_H_
10 | 
11 | #include <iostream>
12 | #include <vector>
13 | using namespace std;
14 | 
15 | // Read a byte
16 | inline int get_val(istream& s)
17 | {
18 |   char cc;
19 |   s.get(cc);
20 |   int a=cc;
21 |   if (a<0) { a+=256; }
22 |   return a;
23 | }
24 | 
25 | // Read a 4-byte integer
26 | inline int get_int(istream& s)
27 | {
28 |   int n = 0;
29 |   for (int i=0; i<4; i++)
30 |     { n<<=8;
31 |       int t=get_val(s);
32 |       n+=t;
33 |     }
34 |   return n;
35 | }
36 | 
37 | // Read several integers
38 | inline void get_ints(int* res, istream& s, int count)
39 | {
40 |   for (int i = 0; i < count; i++)
41 |     res[i] = get_int(s);
42 | }
43 | 
44 | inline void get_vector(int m, vector<int>& start, istream& s)
45 | {
46 |   start.resize(m);
47 |   for (int i = 0; i < m; i++)
48 |     start[i] = get_int(s);
49 | }
50 | 
51 | #endif /* TOOLS_PARSE_H_ */
52 | 


--------------------------------------------------------------------------------
/Tools/pprint.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | 
 4 | #include <iostream>
 5 | #include <iomanip>
 6 | 
 7 | using namespace std;
 8 | 
 9 | inline void pprint_bytes(const char *label, unsigned char *bytes, int len)
10 | {
11 |     cout << label << ": ";
12 |     for (int j = 0; j < len; j++)
13 |         cout << setfill('0') << setw(2) << hex << (int) bytes[j];
14 |     cout << dec << endl;
15 | }
16 | 


--------------------------------------------------------------------------------
/Tools/random.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef _random
 4 | #define _random
 5 | 
 6 | #include "Tools/octetStream.h"
 7 | #include "Tools/sha1.h"
 8 | #include "Tools/aes.h"
 9 | 
10 | #define USE_AES
11 | 
12 | #ifndef USE_AES
13 |   #define PIPELINES   1
14 |   #define SEED_SIZE   HASH_SIZE
15 |   #define RAND_SIZE   HASH_SIZE
16 | #else
17 |   #define PIPELINES   8
18 |   #define SEED_SIZE   AES_BLK_SIZE
19 |   #define RAND_SIZE   (PIPELINES * AES_BLK_SIZE)
20 | #endif
21 | 
22 | 
23 | /* This basically defines a randomness expander, if using
24 |  * as a real PRG on an input stream you should first collapse
25 |  * the input stream down to a SEED, say via CBC-MAC (under 0 key)
26 |  * or via a hash
27 |  */
28 | 
29 | // __attribute__ is needed to get the sse instructions to avoid
30 | //  seg faulting.
31 |      
32 | class PRNG
33 | {
34 |    octet seed[SEED_SIZE]; 
35 |    octet state[RAND_SIZE] __attribute__((aligned (16)));
36 |    octet random[RAND_SIZE] __attribute__((aligned (16)));
37 | 
38 |    #ifdef USE_AES
39 |      bool useC;
40 | 
41 |      // Two types of key schedule for the different implementations 
42 |      // of AES
43 |      uint  KeyScheduleC[44];
44 |      octet KeySchedule[176]  __attribute__((aligned (16)));
45 |    #endif
46 | 
47 |    int cnt;    // How many bytes of the current random value have been used
48 | 
49 |    void hash(); // Hashes state to random and sets cnt=0
50 |    void next();
51 | 
52 |    public:
53 | 
54 |    PRNG();
55 | 
56 |    // For debugging
57 |    void print_state() const;
58 | 
59 |    // Set seed from dev/random
60 |    void ReSeed();
61 | 
62 |    // Set seed from array
63 |    void SetSeed(unsigned char*);
64 |    void SetSeed(PRNG& G);
65 |    void InitSeed();
66 |    
67 |    double get_double();
68 |    bool get_bit() { return get_uchar() & 1; }
69 |    unsigned char get_uchar();
70 |    unsigned int get_uint();
71 |    void get_bigint(bigint& res, int n_bits, bool positive = true);
72 |    void get(bigint& res, int n_bits, bool positive = true);
73 |    void get(int& res, int n_bits, bool positive = true);
74 |    void randomBnd(bigint& res, const bigint& B, bool positive=true);
75 |    bigint randomBnd(const bigint& B, bool positive=true);
76 |    word get_word()
77 |      { word a=get_uint();
78 |        a<<=32; 
79 |        a+=get_uint();
80 |        return a;
81 |      }
82 |    __m128i get_doubleword();
83 |    void get_octetStream(octetStream& ans,int len);
84 |    void get_octets(octet* ans, int len);
85 | 
86 |    const octet* get_seed() const
87 |      { return seed; }
88 | };
89 | 
90 | #endif
91 | 


--------------------------------------------------------------------------------
/Tools/sha1.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef _SHA1
 4 | #define _SHA1
 5 | 
 6 | /*
 7 |  * SHA1 routine optimized to do word accesses rather than byte accesses,
 8 |  * and to avoid unnecessary copies into the context array.
 9 |  *
10 |  * This was initially based on the Mozilla SHA1 implementation, although
11 |  * none of the original Mozilla code remains.
12 |  */
13 | 
14 | #define HASH_SIZE 20
15 | 
16 | typedef struct {
17 | 	unsigned long long size;
18 | 	unsigned int H[5];
19 | 	unsigned int W[16];
20 | } blk_SHA_CTX;
21 | 
22 | void blk_SHA1_Init(blk_SHA_CTX *ctx);
23 | void blk_SHA1_Update(blk_SHA_CTX *ctx, const void *dataIn, unsigned long len);
24 | void blk_SHA1_Final(unsigned char hashout[20], blk_SHA_CTX *ctx);
25 | 
26 | class octetStream;
27 | 
28 | class SHA1 : public blk_SHA_CTX
29 | {
30 | public:
31 |     static const int hash_length = 20;
32 | 
33 | 	SHA1()
34 | 	{ blk_SHA1_Init(this); }
35 | 	void update(const void *dataIn, unsigned long len)
36 | 	{ blk_SHA1_Update(this, dataIn, len); }
37 | 	void update(const octetStream& os);
38 | 	void final(unsigned char hashout[hash_length])
39 | 	{ blk_SHA1_Final(hashout, this); }
40 | 	void final(octetStream& os);
41 | };
42 | 
43 | #define git_SHA_CTX	blk_SHA_CTX
44 | #define git_SHA1_Init	blk_SHA1_Init
45 | #define git_SHA1_Update	blk_SHA1_Update
46 | #define git_SHA1_Final	blk_SHA1_Final
47 | 
48 | #endif
49 | 


--------------------------------------------------------------------------------
/Tools/time-func.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | 
 4 | #include "Tools/time-func.h"
 5 | #include "Exceptions/Exceptions.h"
 6 | 
 7 | 
 8 | long long timeval_diff(struct timeval *start_time, struct timeval *end_time)
 9 | { struct timeval temp_diff;
10 |   struct timeval *difference;
11 |   difference=&temp_diff;
12 |   difference->tv_sec =end_time->tv_sec -start_time->tv_sec ;
13 |   difference->tv_usec=end_time->tv_usec-start_time->tv_usec;
14 |   while(difference->tv_usec<0)
15 |   { difference->tv_usec+=1000000;
16 |     difference->tv_sec -=1;
17 |   }
18 |   return 1000000LL*difference->tv_sec+difference->tv_usec;
19 | }
20 | 
21 | double timeval_diff_in_seconds(struct timeval *start_time, struct timeval *end_time)
22 | {
23 |     return double(timeval_diff(start_time, end_time)) / 1e6;
24 | }
25 | 
26 | 
27 | long long timespec_diff(struct timespec *start_time, struct timespec *end_time)
28 | {
29 |   long long sec =end_time->tv_sec -start_time->tv_sec ;
30 |   long long nsec=end_time->tv_nsec-start_time->tv_nsec;
31 |   while(nsec<0)
32 |   { nsec+=1000000000;
33 |     sec -=1;
34 |   }
35 |   return 1000000000*sec+nsec;
36 | }
37 | 
38 | 
39 | double convert_ns_to_seconds(long long x)
40 | {
41 |   return double(x) / 1e9;
42 | }
43 | 
44 | 
45 | double Timer::elapsed()
46 | {
47 |   long long res = elapsed_time;
48 |   if (running)
49 |     res += elapsed_since_last_start();
50 |   return convert_ns_to_seconds(res);
51 | }
52 | 
53 | double Timer::idle()
54 | {
55 |   if (running)
56 |     throw Processor_Error("Timer running.");
57 |   else
58 |     return convert_ns_to_seconds(elapsed_since_last_start());
59 | }
60 | 


--------------------------------------------------------------------------------
/Tools/time-func.h:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #ifndef _timer
 4 | #define _timer
 5 | 
 6 | #include <sys/wait.h>   /* Wait for Process Termination */
 7 | #include <sys/time.h>
 8 | #include <time.h>
 9 | 
10 | #include "Exceptions/Exceptions.h"
11 | 
12 | long long timeval_diff(struct timeval *start_time, struct timeval *end_time);
13 | double timeval_diff_in_seconds(struct timeval *start_time, struct timeval *end_time);
14 | long long timespec_diff(struct timespec *start_time, struct timespec *end_time);
15 | 
16 | class Timer
17 | {
18 |   public:
19 |   Timer(clockid_t clock_id = CLOCK_MONOTONIC) : running(false), elapsed_time(0), clock_id(clock_id)
20 |       { clock_gettime(clock_id, &startv); }
21 |   Timer& start();
22 |   void stop();
23 |   void reset();
24 | 
25 |   double elapsed();
26 |   double idle();
27 | 
28 |   private:
29 |   timespec startv;
30 |   bool running;
31 |   long long elapsed_time;
32 |   clockid_t clock_id;
33 | 
34 |   long long elapsed_since_last_start();
35 | };
36 | 
37 | class TimeScope
38 | {
39 |   Timer& timer;
40 | 
41 | public:
42 |   TimeScope(Timer& timer) : timer(timer) { timer.start(); }
43 |   ~TimeScope() { timer.stop(); }
44 | };
45 | 
46 | inline Timer& Timer::start()
47 | {
48 |   if (running)
49 |     throw Processor_Error("Timer already running.");
50 |   // clock() is not suitable in threaded programs so time using something else
51 |   clock_gettime(clock_id, &startv);
52 |   running = true;
53 |   return *this;
54 | }
55 | 
56 | inline void Timer::stop()
57 | {
58 |   if (!running)
59 |     throw Processor_Error("Time not running.");
60 |   elapsed_time += elapsed_since_last_start();
61 | 
62 |   running = false;
63 |   clock_gettime(clock_id, &startv);
64 | }
65 | 
66 | inline void Timer::reset()
67 | {
68 |   elapsed_time = 0;
69 |   clock_gettime(clock_id, &startv);
70 | }
71 | 
72 | inline long long Timer::elapsed_since_last_start()
73 | {
74 |   timespec endv;
75 |   clock_gettime(clock_id, &endv);
76 |   return timespec_diff(&startv, &endv);
77 | }
78 | 
79 | #endif
80 | 
81 | 


--------------------------------------------------------------------------------
/check-passive.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #include "Math/gf2n.h"
 4 | #include "Math/gfp.h"
 5 | #include "Math/Setup.h"
 6 | 
 7 | #include <fstream>
 8 | #include <vector>
 9 | #include <numeric>
10 | 
11 | template <class T>
12 | void check_triples(int n_players)
13 | {
14 |     ifstream* inputFiles = new ifstream[n_players];
15 |     for (int i = 0; i < n_players; i++)
16 |     {
17 |         stringstream ss;
18 |         ss << get_prep_dir(n_players, 128, 128) << "Triples-" << T::type_char() << "-P" << i;
19 |         inputFiles[i].open(ss.str().c_str());
20 |         cout << "Opening file " << ss.str() << endl;
21 |     }
22 | 
23 |     int j = 0;
24 |     while (inputFiles[0].peek() != EOF)
25 |     {
26 |         T a,b,c,cc,tmp;
27 |         vector<T> as(n_players), bs(n_players), cs(n_players);
28 |         for (int i = 0; i < n_players; i++)
29 |         {
30 |             as[i].input(inputFiles[i], false);
31 |             bs[i].input(inputFiles[i], false);
32 |             cs[i].input(inputFiles[i], false);
33 |         }
34 | 
35 |         a = accumulate(as.begin(), as.end(), T());
36 |         b = accumulate(bs.begin(), bs.end(), T());
37 |         c = accumulate(cs.begin(), cs.end(), T());
38 | 
39 |         if (a * b != c)
40 |         {
41 |             cout << T::type_string() << ": Error in " << j << endl;
42 |             cout << "a " << a << " " << as[0] << " " << as[1] << endl;
43 |             cout << "b " << b << " " << bs[0] << " " << bs[1] << endl;
44 |             cout << "c " << c << " " << cs[0] << " " << cs[1] << endl;
45 |             for (int i = 0; i < 2; i++)
46 |                 for (int j = 0; j < 2; j++)
47 |                 {
48 |                     tmp = as[i] * bs[j];
49 |                     cc += tmp;
50 |                     cout << "a" << i << " * b" << j << " " << tmp << endl;
51 |                 }
52 |             cout << "cc " << cc << endl;
53 |             cout << "a*b " << a*b << endl;
54 |             cout << "DID YOU INDICATE THE CORRECT NUMBER OF PLAYERS?" << endl;
55 | 
56 |             return;
57 |         }
58 | 
59 |         j++;
60 |     }
61 | 
62 |     cout << j << " correct triples of type " << T::type_string() << endl;
63 |     delete[] inputFiles;
64 | }
65 | 
66 | int main(int argc, char** argv)
67 | {
68 |     int n_players = 2;
69 |     if (argc > 1)
70 |         n_players = atoi(argv[1]);
71 |     read_setup(n_players, 128, 128);
72 |     gfp::init_field(gfp::pr(), false);
73 |     check_triples<gf2n>(n_players);
74 |     check_triples<gfp>(n_players);
75 | }
76 | 


--------------------------------------------------------------------------------
/cnc-offline.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * cnc-offline.cpp
 5 |  *
 6 |  */
 7 | 
 8 | #include "FHEOffline/CutAndChooseMachine.h"
 9 | 
10 | int main(int argc, const char** argv)
11 | {
12 |     CutAndChooseMachine(argc, argv).run();
13 |     return 0;
14 | }
15 | 


--------------------------------------------------------------------------------
/ot-offline.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * OT-Offline.cpp
 5 |  *
 6 |  */
 7 | 
 8 | #include "OT/NPartyTripleGenerator.h"
 9 | 
10 | int main(int argc, const char** argv)
11 | {
12 |     TripleMachine(argc, argv).run();
13 | }
14 | 


--------------------------------------------------------------------------------
/pairwise-offline.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | #include "FHEOffline/PairwiseMachine.h"
 4 | #include <valgrind/callgrind.h>
 5 | 
 6 | int main(int argc, const char** argv)
 7 | {
 8 |     CALLGRIND_STOP_INSTRUMENTATION;
 9 |     PairwiseMachine machine(argc, argv);
10 |     CALLGRIND_START_INSTRUMENTATION;
11 |     machine.run();
12 | }
13 | 


--------------------------------------------------------------------------------
/simple-offline.cpp:
--------------------------------------------------------------------------------
 1 | // (C) 2018 University of Bristol. See License.txt
 2 | 
 3 | /*
 4 |  * simple-offline.cpp
 5 |  *
 6 |  */
 7 | 
 8 | #include <FHEOffline/SimpleMachine.h>
 9 | #include <valgrind/callgrind.h>
10 | 
11 | int main(int argc, const char** argv)
12 | {
13 |     CALLGRIND_STOP_INSTRUMENTATION;
14 |     SimpleMachine machine(argc, argv);
15 |     CALLGRIND_START_INSTRUMENTATION;
16 |     machine.run();
17 | }
18 | 


--------------------------------------------------------------------------------