github/MP-SPDZ
1
1
Fork 0
mirror of https://github.com/data61/MP-SPDZ.git synced 2026-05-13 03:00:24 -04:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #426 from carbynestack/add-prng-seed-option

Browse Source 
Add option for providing seed for PRNG
This commit is contained in:
Marcel Keller
2023-06-16 11:53:00 +10:00
committed by GitHub
parent 82b2b533e1 39f75a6319
commit bc28d8bb06
4 changed files with 143 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
ECDSA/Fake-ECDSA.cpp
View File

@@ -19,8 +19,10 @@ int main()
string prefix = PREP_DIR "ECDSA/";
mkdir_p(prefix.c_str());
write_online_setup(prefix, P256Element::Scalar::pr());
generate_mac_keys<Share<P256Element::Scalar>>(key, 2, prefix);
make_mult_triples<Share<P256Element::Scalar>>(key, 2, 1000, false, prefix);
make_inverse<Share<P256Element::Scalar>>(key, 2, 1000, false, prefix);
PRNG G;
G.ReSeed();
generate_mac_keys<Share<P256Element::Scalar>>(key, 2, prefix, G);
make_mult_triples<Share<P256Element::Scalar>>(key, 2, 1000, false, prefix, G);
make_inverse<Share<P256Element::Scalar>>(key, 2, 1000, false, prefix, G);
P256Element::finish();
}

9
Protocols/fake-stuff.h
View File

@@ -47,16 +47,16 @@ public:
typename T::mac_type key;
PRNG G;
Files(int N, const typename T::mac_type& key, const string& prep_data_prefix,
Dtype type, int thread_num = -1) :
Dtype type, PRNG& G, int thread_num = -1) :
Files(N, key,
get_prep_sub_dir<T>(prep_data_prefix, N, true)
+ DataPositions::dtype_names[type] + "-" + T::type_short(),
thread_num)
G, thread_num)
{
}
Files(int N, const typename T::mac_type& key, const string& prefix,
int thread_num = -1) :
N(N), key(key)
PRNG& G, int thread_num = -1) :
N(N), key(key), G(G)
{
insecure_fake(false);
outf = new ofstream[N];
@@ -71,7 +71,6 @@ public:
if (outf[i].fail())
throw file_error(filename.str().c_str());
}
G.ReSeed();
}
~Files()
{

23
Protocols/fake-stuff.hpp
View File

@@ -443,9 +443,8 @@ T reconstruct(vector<MaliciousShamirShare<T>>& shares)
template<class T>
void make_mac_key_share(typename T::mac_share_type::open_type& key,
vector<typename T::mac_share_type>& key_shares, int nplayers, T)
vector<typename T::mac_share_type>& key_shares, int nplayers, T, PRNG& G)
{
SeededPRNG G;
key.randomize(G);
make_share(key_shares.data(), key, nplayers, GC::NoShare(), G);
assert(not key_shares[0].is_zero());
@@ -453,9 +452,8 @@ void make_mac_key_share(typename T::mac_share_type::open_type& key,
template<int K, int S>
void make_mac_key_share(Z2<K + S>& key,
vector<SemiShare<Z2<K + S>>>& key_shares, int nplayers, Spdz2kShare<K, S>)
vector<SemiShare<Z2<K + S>>>& key_shares, int nplayers, Spdz2kShare<K, S>, PRNG& G)
{
SeededPRNG G;
key = {};
key_shares.resize(nplayers);
for (int i = 0; i < nplayers; i++)
@@ -468,7 +466,7 @@ void make_mac_key_share(Z2<K + S>& key,
template<class T>
void generate_mac_keys(typename T::mac_share_type::open_type& key,
int nplayers, string prep_data_prefix)
int nplayers, string prep_data_prefix, PRNG& G)
{
key.assign_zero();
int tmpN = 0;
@@ -508,7 +506,7 @@ void generate_mac_keys(typename T::mac_share_type::open_type& key,
if (generate)
{
make_mac_key_share(key, key_shares, nplayers, T());
make_mac_key_share(key, key_shares, nplayers, T(), G);
for (int i = 0; i < nplayers; i++)
{
@@ -542,14 +540,11 @@ inline void check_files(ofstream* outf, int N)
*/
template<class T>
void make_mult_triples(const typename T::mac_type& key, int N, int ntrip,
bool zero, string prep_data_prefix, int thread_num = -1)
bool zero, string prep_data_prefix, PRNG& G, int thread_num = -1)
{
T::clear::write_setup(get_prep_sub_dir<T>(prep_data_prefix, N));
Files<T> files(N, key, prep_data_prefix, DATA_TRIPLE, G, thread_num);
PRNG G;
G.ReSeed();
Files<T> files(N, key, prep_data_prefix, DATA_TRIPLE, thread_num);
typename T::clear a,b,c;
/* Generate Triples */
for (int i=0; i<ntrip; i++)
@@ -571,12 +566,10 @@ void make_mult_triples(const typename T::mac_type& key, int N, int ntrip,
*/
template<class T>
void make_inverse(const typename T::mac_type& key, int N, int ntrip, bool zero,
string prep_data_prefix)
string prep_data_prefix, PRNG& G)
{
PRNG G;
G.ReSeed();
Files<T> files(N, key, prep_data_prefix, DATA_INVERSE);
Files<T> files(N, key, prep_data_prefix, DATA_INVERSE, G);
typename T::clear a,b;
for (int i=0; i<ntrip; i++)
{

242
Utils/Fake-Offline.cpp
View File

@@ -56,27 +56,27 @@ public:
int generate();
template<class T>
void generate_field(true_type);
void generate_field(true_type, PRNG& G);
template<class T>
void generate_field(false_type)
void generate_field(false_type, PRNG&)
{
}
template<int K>
void generate_ring();
void generate_ring(PRNG& G);
template<class T>
void make_with_mac_key(int nplayers, int default_num, bool zero,
void make_with_mac_key(int nplayers, int default_num, bool zero,PRNG& G,
const typename T::bit_type::mac_type& bit_key = {});
template<class T>
void make_basic(const typename T::mac_type& key, int nplayers, int nitems,
bool zero, const typename T::bit_type::mac_type& bit_key = {});
bool zero, PRNG& G, const typename T::bit_type::mac_type& bit_key = {});
template<class T>
void make_edabits(const typename T::mac_type& key, int N, int ntrip, bool zero, false_type,
void make_edabits(const typename T::mac_type& key, int N, int ntrip, bool zero, PRNG& G, false_type,
const typename T::bit_type::mac_type& bit_key = {});
template<class T>
void make_edabits(const typename T::mac_type&, int, int, bool, true_type,
void make_edabits(const typename T::mac_type&, int, int, bool, PRNG&, true_type,
const typename T::bit_type::mac_type& = {})
{
}
@@ -87,14 +87,10 @@ public:
* ntrip = Number tuples needed
*/
template<class T>
void make_square_tuples(const typename T::mac_type& key,int N,int ntrip,const string& str,bool zero)
void make_square_tuples(const typename T::mac_type& key,int N,int ntrip,const string& str,bool zero,PRNG& G)
{
(void) str;
PRNG G;
G.ReSeed();
Files<T> files(N, key, prep_data_prefix, DATA_SQUARE);
Files<T> files(N, key, prep_data_prefix, DATA_SQUARE, G);
typename T::clear a,c;
/* Generate Squares */
for (int i=0; i<ntrip; i++)
@@ -112,13 +108,11 @@ void make_square_tuples(const typename T::mac_type& key,int N,int ntrip,const st
* ntrip = Number bits needed
*/
template<class T>
void make_bits(const typename T::mac_type& key, int N, int ntrip, bool zero,
void make_bits(const typename T::mac_type& key, int N, int ntrip, bool zero, PRNG& G,
int thread_num = -1)
{
PRNG G;
G.ReSeed();
Files<T> files(N, key, prep_data_prefix, DATA_BIT, thread_num);
Files<T> files(N, key, prep_data_prefix, DATA_BIT, G, thread_num);
typename T::clear a;
/* Generate Bits */
for (int i=0; i<ntrip; i++)
@@ -130,13 +124,12 @@ void make_bits(const typename T::mac_type& key, int N, int ntrip, bool zero,
}
template<class T>
void make_dabits(const typename T::mac_type& key, int N, int ntrip, bool zero,
void make_dabits(const typename T::mac_type& key, int N, int ntrip, bool zero, PRNG& G,
const typename T::bit_type::mac_type& bit_key = { })
{
Files<T> files(N, key,
get_prep_sub_dir<T>(prep_data_prefix, N)
+ DataPositions::dtype_names[DATA_DABIT] + "-" + T::type_short());
SeededPRNG G;
+ DataPositions::dtype_names[DATA_DABIT] + "-" + T::type_short(), G);
for (int i = 0; i < ntrip; i++)
{
bool bit = not zero && G.get_bit();
@@ -146,7 +139,7 @@ void make_dabits(const typename T::mac_type& key, int N, int ntrip, bool zero,
}
template<class T>
void FakeParams::make_edabits(const typename T::mac_type& key, int N, int ntrip, bool zero, false_type,
void FakeParams::make_edabits(const typename T::mac_type& key, int N, int ntrip, bool zero, PRNG& G, false_type,
const typename T::bit_type::mac_type& bit_key)
{
vector<int> lengths;
@@ -155,8 +148,7 @@ void FakeParams::make_edabits(const typename T::mac_type& key, int N, int ntrip,
{
Files<T> files(N, key,
get_prep_sub_dir<T>(prep_data_prefix, N)
+ "edaBits-" + to_string(length));
SeededPRNG G;
+ "edaBits-" + to_string(length), G);
bigint value;
int max_size = edabitvec<T>::MAX_SIZE;
for (int i = 0; i < ntrip / max_size; i++)
@@ -176,13 +168,10 @@ void FakeParams::make_edabits(const typename T::mac_type& key, int N, int ntrip,
* ntrip = Number inputs needed
*/
template<class T>
void make_inputs(const typename T::mac_type& key,int N,int ntrip,const string& str,bool zero)
void make_inputs(const typename T::mac_type& key,int N,int ntrip,const string& str,bool zero,PRNG& G)
{
(void) str;
PRNG G;
G.ReSeed();
ofstream* outf=new ofstream[N];
typename T::open_type a;
vector<T> Sa(N);
@@ -219,13 +208,11 @@ void make_inputs(const typename T::mac_type& key,int N,int ntrip,const string& s
template<class T>
void make_PreMulC(const typename T::mac_type& key, int N, int ntrip, bool zero)
void make_PreMulC(const typename T::mac_type& key, int N, int ntrip, bool zero, PRNG& G)
{
stringstream ss;
ss << get_prep_sub_dir<T>(prep_data_prefix, N) << "PreMulC-" << T::type_short();
Files<T> files(N, key, ss.str());
PRNG G;
G.ReSeed();
Files<T> files(N, key, ss.str(), G);
typename T::clear a, b, c;
c = 1;
for (int i=0; i<ntrip; i++)
@@ -266,12 +253,10 @@ unsigned char sbox[256] =
};
template<class T>
void make_AES(const typename T::mac_type& key, int N, int ntrip, bool zero) {
void make_AES(const typename T::mac_type& key, int N, int ntrip, bool zero, PRNG& G) {
stringstream ss;
ss << get_prep_sub_dir<T>(prep_data_prefix, N) << "Sbox-" << T::type_short();
Files<T> files(N, key, ss.str());
PRNG G;
G.ReSeed();
Files<T> files(N, key, ss.str(), G);
gf2n_short x;
for (int i = 0; i < ntrip; i++)
@@ -304,13 +289,11 @@ vector<vector<unsigned char>> des_sbox = {
template<class T>
void make_DES(const typename T::mac_type& key, int N, int ntrip, bool zero)
void make_DES(const typename T::mac_type& key, int N, int ntrip, bool zero, PRNG& G)
{
stringstream ss;
ss << get_prep_sub_dir<T>(prep_data_prefix, N) << "SboxDes-" << T::type_short();
Files<T> files(N, key, ss.str());
PRNG G;
G.ReSeed();
Files<T> files(N, key, ss.str(), G);
gf2n_short x;
for (int i = 0; i < ntrip; i++)
@@ -331,60 +314,60 @@ void make_DES(const typename T::mac_type& key, int N, int ntrip, bool zero)
}
template<class T>
void make_Sbox(const typename T::mac_type& key, int N, int ntrip, bool zero, T, true_type)
void make_Sbox(const typename T::mac_type& key, int N, int ntrip, bool zero, PRNG& G, T, true_type)
{
make_AES<T>(key, N, ntrip, zero);
make_DES<T>(key, N, ntrip, zero);
make_AES<T>(key, N, ntrip, zero, G);
make_DES<T>(key, N, ntrip, zero, G);
}
template<class T>
void make_Sbox(const typename T::mac_type& key, int N, int ntrip, bool zero, T, false_type)
void make_Sbox(const typename T::mac_type& key, int N, int ntrip, bool zero, PRNG&, T, false_type)
{
(void)key, (void)N, (void)ntrip, (void)zero;
}
template<class T>
void make_Sbox(const typename T::mac_type& key, int N, int ntrip, bool zero)
void make_Sbox(const typename T::mac_type& key, int N, int ntrip, bool zero, PRNG& G)
{
make_Sbox(key, N, ntrip, zero, T(), T::clear::characteristic_two);
make_Sbox(key, N, ntrip, zero, G, T(), T::clear::characteristic_two);
}
template<class T>
void make_minimal(const typename T::mac_type& key, int nplayers, int nitems, bool zero)
void make_minimal(const typename T::mac_type& key, int nplayers, int nitems, bool zero, PRNG& G)
{
make_mult_triples<T>(key, nplayers, nitems, zero, prep_data_prefix);
make_bits<T>(key, nplayers, nitems, zero);
make_inputs<T>(key, nplayers, nitems, T::type_short(), zero);
make_mult_triples<T>(key, nplayers, nitems, zero, prep_data_prefix, G);
make_bits<T>(key, nplayers, nitems, zero, G);
make_inputs<T>(key, nplayers, nitems, T::type_short(), zero, G);
}
template<class T>
void FakeParams::make_basic(const typename T::mac_type& key, int nplayers,
int nitems, bool zero, const typename T::bit_type::mac_type& bit_key)
void FakeParams::make_basic(const typename T::mac_type& key, int nplayers,
int nitems, bool zero, PRNG& G, const typename T::bit_type::mac_type& bit_key)
{
make_minimal<T>(key, nplayers, nitems, zero);
make_square_tuples<T>(key, nplayers, nitems, T::type_short(), zero);
make_dabits<T>(key, nplayers, nitems, zero, bit_key);
make_edabits<T>(key, nplayers, nitems, zero, T::clear::characteristic_two,
make_minimal<T>(key, nplayers, nitems, zero, G);
make_square_tuples<T>(key, nplayers, nitems, T::type_short(), zero, G);
make_dabits<T>(key, nplayers, nitems, zero, G, bit_key);
make_edabits<T>(key, nplayers, nitems, zero, G, T::clear::characteristic_two,
bit_key);
if (T::clear::invertible)
{
make_inverse<T>(key, nplayers, nitems, zero, prep_data_prefix);
make_inverse<T>(key, nplayers, nitems, zero, prep_data_prefix, G);
if (opt.isSet("-s"))
{
make_PreMulC<T>(key, nplayers, nitems, zero);
make_Sbox<T>(key, nplayers, nitems, zero);
make_PreMulC<T>(key, nplayers, nitems, zero, G);
make_Sbox<T>(key, nplayers, nitems, zero, G);
}
}
}
template<class T>
void FakeParams::make_with_mac_key(int nplayers, int default_num, bool zero,
void FakeParams::make_with_mac_key(int nplayers, int default_num, bool zero, PRNG& G,
const typename T::bit_type::mac_type& bit_key)
{
typename T::mac_share_type::open_type key;
generate_mac_keys<T>(key, nplayers, prep_data_prefix);
make_basic<T>(key, nplayers, default_num, zero, bit_key);
generate_mac_keys<T>(key, nplayers, prep_data_prefix, G);
make_basic<T>(key, nplayers, default_num, zero, G, bit_key);
}
template<class T>
@@ -565,6 +548,16 @@ int main(int argc, const char** argv)
"-n", // Flag token.
"--nontgomery" // Flag token.
);
opt.add(
"", // Default.
0, // Required?
1, // Number of args expected.
0, // Delimiter if expecting multiple args.
"Seed to use for initializing pseudorandom number generator"
"(default: seed from /dev/random)", // Help description.
"-seed", // Flag token.
"--prngseed" // Flag token.
);
opt.parse(argc, argv);
int lgp;
@@ -681,8 +674,25 @@ int FakeParams::generate()
// check compatibility
gf2n::init_field(lg2);
// Initialize PRNG
PRNG G;
G.ReSeed();
if (opt.isSet("--prngseed")) {
std::string seed;
opt.get("--prngseed")->getString(seed);
if (seed.length() != SEED_SIZE) {
cerr << "ERROR: invalid seed length. Must be " << SEED_SIZE << " bytes";
opt.getUsage(usage);
cout << usage;
return 1;
}
unsigned char *val = new unsigned char[seed.length()+1];
strcpy((char *)val, seed.c_str());
G.SetSeed(val);
delete [] val;
} else {
G.ReSeed();
}
prep_data_prefix = PREP_DIR;
// Set up the fields
if (opt.isSet("--prime"))
@@ -711,59 +721,59 @@ int FakeParams::generate()
typedef Share<gf2n> sgf2n;
generate_mac_keys<T>(keyp, nplayers, prep_data_prefix);
generate_mac_keys<sgf2n>(key2, nplayers, prep_data_prefix);
generate_mac_keys<T>(keyp, nplayers, prep_data_prefix, G);
generate_mac_keys<sgf2n>(key2, nplayers, prep_data_prefix, G);
make_mult_triples<sgf2n>(key2,nplayers,ntrip2,zero,prep_data_prefix);
make_mult_triples<T>(keyp,nplayers,ntripp,zero,prep_data_prefix);
make_bits<Share<gf2n>>(key2,nplayers,nbits2,zero);
make_bits<T>(keyp,nplayers,nbitsp,zero);
make_square_tuples<sgf2n>(key2,nplayers,nsqr2,"2",zero);
make_square_tuples<T>(keyp,nplayers,nsqrp,"p",zero);
make_inputs<sgf2n>(key2,nplayers,ninp2,"2",zero);
make_inputs<T>(keyp,nplayers,ninpp,"p",zero);
make_inverse<sgf2n>(key2,nplayers,ninv,zero,prep_data_prefix);
make_mult_triples<sgf2n>(key2,nplayers,ntrip2,zero,prep_data_prefix,G);
make_mult_triples<T>(keyp,nplayers,ntripp,zero,prep_data_prefix,G);
make_bits<Share<gf2n>>(key2,nplayers,nbits2,zero,G);
make_bits<T>(keyp,nplayers,nbitsp,zero,G);
make_square_tuples<sgf2n>(key2,nplayers,nsqr2,"2",zero,G);
make_square_tuples<T>(keyp,nplayers,nsqrp,"p",zero,G);
make_inputs<sgf2n>(key2,nplayers,ninp2,"2",zero,G);
make_inputs<T>(keyp,nplayers,ninpp,"p",zero,G);
make_inverse<sgf2n>(key2,nplayers,ninv,zero,prep_data_prefix,G);
if (T::clear::invertible)
make_inverse<T>(keyp,nplayers,ninv,zero,prep_data_prefix);
make_inverse<T>(keyp,nplayers,ninv,zero,prep_data_prefix,G);
if (opt.isSet("-s"))
{
make_PreMulC<sgf2n>(key2,nplayers,ninv,zero);
make_PreMulC<sgf2n>(key2,nplayers,ninv,zero,G);
if (T::clear::invertible)
make_PreMulC<T>(keyp,nplayers,ninv,zero);
make_Sbox<sgf2n>(key2,nplayers,ninv,zero);
make_PreMulC<T>(keyp,nplayers,ninv,zero,G);
make_Sbox<sgf2n>(key2,nplayers,ninv,zero,G);
}
// replicated secret sharing only for three parties
if (nplayers == 3)
{
make_mult_triples<GC::MaliciousRepSecret>({}, nplayers, ntrip2, zero, prep_data_prefix);
make_bits<GC::MaliciousRepSecret>({}, nplayers, nbits2, zero);
make_mult_triples<GC::MaliciousRepSecret>({}, nplayers, ntrip2, zero, prep_data_prefix, G);
make_bits<GC::MaliciousRepSecret>({}, nplayers, nbits2, zero, G);
}
else if (nplayers == 4)
make_basic<Rep4Share2<64>>({}, nplayers, default_num, zero);
make_basic<Rep4Share2<64>>({}, nplayers, default_num, zero, G);
make_minimal<GC::DealerSecret>({}, nplayers, default_num, zero);
make_minimal<GC::DealerSecret>({}, nplayers, default_num, zero, G);
make_mult_triples<GC::SemiSecret>({}, nplayers, default_num, zero, prep_data_prefix);
make_bits<GC::SemiSecret>({}, nplayers, default_num, zero);
make_mult_triples<GC::SemiSecret>({}, nplayers, default_num, zero, prep_data_prefix, G);
make_bits<GC::SemiSecret>({}, nplayers, default_num, zero, G);
gf2n_short::reset();
gf2n_short::init_field();
Z2<DEFAULT_SECURITY + 1> keyt;
generate_mac_keys<GC::TinySecret<DEFAULT_SECURITY>>(keyt, nplayers,
prep_data_prefix);
prep_data_prefix, G);
make_minimal<GC::TinySecret<DEFAULT_SECURITY>>(keyt, nplayers,
default_num / 64, zero);
default_num / 64, zero, G);
gf2n_short keytt;
generate_mac_keys<GC::TinierShare<gf2n_short>>(keytt, nplayers, prep_data_prefix);
make_minimal<GC::TinierShare<gf2n_short>>(keytt, nplayers, default_num, zero);
generate_mac_keys<GC::TinierShare<gf2n_short>>(keytt, nplayers, prep_data_prefix, G);
make_minimal<GC::TinierShare<gf2n_short>>(keytt, nplayers, default_num, zero, G);
make_dabits<T>(keyp, nplayers, default_num, zero, keytt);
make_edabits<T>(keyp, nplayers, default_num, zero, false_type(), keytt);
make_dabits<T>(keyp, nplayers, default_num, zero, G, keytt);
make_edabits<T>(keyp, nplayers, default_num, zero, G, false_type(), keytt);
if (T::clear::prime_field)
{
@@ -774,7 +784,7 @@ int FakeParams::generate()
#define X(N) if (N == n_macs) \
make_with_mac_key<MamaShare<typename T::clear, N>>(nplayers, \
default_num, zero, keytt);
default_num, zero, G, keytt);
X(1) X(2) X(4) X(10)
#undef X
@@ -783,25 +793,25 @@ int FakeParams::generate()
if (nplayers > 2)
{
make_mult_triples<GC::MaliciousCcdShare<gf2n_short>>({}, nplayers,
default_num, zero, prep_data_prefix);
default_num, zero, prep_data_prefix, G);
make_bits<GC::MaliciousCcdShare<gf2n_short>>({}, nplayers,
default_num, zero);
default_num, zero, G);
}
generate_field<typename T::clear>(T::clear::prime_field);
generate_field<gf2n>(true_type());
generate_field<typename T::clear>(T::clear::prime_field, G);
generate_field<gf2n>(true_type(), G);
if (gf2n::degree() != gf2n_short::degree())
generate_field<gf2n_short>(true_type());
generate_field<gf2n_short>(true_type(), G);
// default
generate_ring<64>();
generate_ring<64>(G);
// reuse lgp for simplified interface
switch (lgp)
{
case 64:
break;
#define X(L) case L: generate_ring<L>(); break;
#define X(L) case L: generate_ring<L>(G); break;
X(128) X(192) X(256)
default:
cerr << "Not compiled for " << lgp << "-bit rings." << endl << "Add 'X("
@@ -813,47 +823,47 @@ int FakeParams::generate()
}
template<class U>
void FakeParams::generate_field(true_type)
void FakeParams::generate_field(true_type, PRNG& G)
{
if (nplayers == 3)
{
make_basic<Rep3Share<U>>({}, nplayers, default_num, zero);
make_basic<MaliciousRep3Share<U>>({}, nplayers, default_num, zero);
make_basic<PostSacriRepFieldShare<U>>({}, nplayers, default_num, zero);
make_with_mac_key<SpdzWiseShare<MaliciousRep3Share<U>>>(nplayers, default_num, zero);
make_basic<Rep3Share<U>>({}, nplayers, default_num, zero, G);
make_basic<MaliciousRep3Share<U>>({}, nplayers, default_num, zero, G);
make_basic<PostSacriRepFieldShare<U>>({}, nplayers, default_num, zero, G);
make_with_mac_key<SpdzWiseShare<MaliciousRep3Share<U>>>(nplayers, default_num, zero, G);
}
else if (nplayers == 4)
make_basic<Rep4Share<U>>({}, nplayers, default_num, zero);
make_basic<Rep4Share<U>>({}, nplayers, default_num, zero, G);
make_basic<SemiShare<U>>({}, nplayers, default_num, zero);
make_basic<DealerShare<U>>({}, nplayers, default_num, zero);
make_basic<SemiShare<U>>({}, nplayers, default_num, zero, G);
make_basic<DealerShare<U>>({}, nplayers, default_num, zero, G);
if (nplayers > 2)
{
ShamirShare<U>::bit_type::clear::init_field();
make_basic<ShamirShare<U>>({}, nplayers, default_num, zero);
make_basic<MaliciousShamirShare<U>>({}, nplayers, default_num, zero);
make_basic<ShamirShare<U>>({}, nplayers, default_num, zero, G);
make_basic<MaliciousShamirShare<U>>({}, nplayers, default_num, zero, G);
make_with_mac_key<SpdzWiseShare<MaliciousShamirShare<U>>>(nplayers,
default_num, zero);
default_num, zero, G);
}
}
template<int K>
inline void FakeParams::generate_ring()
inline void FakeParams::generate_ring(PRNG& G)
{
if (nplayers == 3)
{
make_bits<Rep3Share2<K>>({}, nplayers, default_num, zero);
make_bits<Rep3Share2<K>>({}, nplayers, default_num, zero, G);
make_basic<BrainShare<K, DEFAULT_SECURITY>>({}, nplayers, default_num,
zero);
zero, G);
make_basic<PostSacriRepRingShare<K, DEFAULT_SECURITY>>({}, nplayers,
default_num, zero);
default_num, zero, G);
make_with_mac_key<SpdzWiseRingShare<K, DEFAULT_SECURITY>>(nplayers,
default_num, zero);
default_num, zero, G);
}
else if (nplayers == 4)
make_basic<Rep4Share2<K>>({}, nplayers, default_num, zero);
make_basic<Rep4Share2<K>>({}, nplayers, default_num, zero, G);
make_basic<SemiShare<Z2<K>>>({}, nplayers, default_num, zero);
make_basic<DealerShare<Z2<K>>>({}, nplayers, default_num, zero);
make_basic<SemiShare<Z2<K>>>({}, nplayers, default_num, zero, G);
make_basic<DealerShare<Z2<K>>>({}, nplayers, default_num, zero, G);
}