mirror of
https://github.com/data61/MP-SPDZ.git
synced 2026-01-09 13:37:58 -05:00
133 lines
3.8 KiB
C++
133 lines
3.8 KiB
C++
/*
|
|
* preprocessing.hpp
|
|
*
|
|
*/
|
|
|
|
#ifndef ECDSA_PREPROCESSING_HPP_
|
|
#define ECDSA_PREPROCESSING_HPP_
|
|
|
|
#include "P256Element.h"
|
|
#include "EcdsaOptions.h"
|
|
#include "Processor/Data_Files.h"
|
|
#include "Protocols/ReplicatedPrep.h"
|
|
#include "Protocols/MaliciousShamirShare.h"
|
|
#include "Protocols/Rep3Share.h"
|
|
#include "GC/TinierSecret.h"
|
|
#include "GC/MaliciousCcdSecret.h"
|
|
#include "GC/TinyMC.h"
|
|
|
|
#include "GC/TinierSharePrep.hpp"
|
|
#include "GC/CcdSecret.h"
|
|
|
|
template<template<class U> class T>
|
|
class EcTuple
|
|
{
|
|
public:
|
|
T<P256Element::Scalar> a;
|
|
T<P256Element::Scalar> b;
|
|
P256Element::Scalar c;
|
|
T<P256Element> secret_R;
|
|
P256Element R;
|
|
};
|
|
|
|
template<template<class U> class T>
|
|
void preprocessing(vector<EcTuple<T>>& tuples, int buffer_size,
|
|
T<P256Element::Scalar>& sk,
|
|
SubProcessor<T<P256Element::Scalar>>& proc,
|
|
EcdsaOptions opts)
|
|
{
|
|
bool prep_mul = opts.prep_mul;
|
|
if (prep_mul)
|
|
proc.protocol.init_mul();
|
|
|
|
Timer timer;
|
|
timer.start();
|
|
Player& P = proc.P;
|
|
auto& prep = proc.DataF;
|
|
size_t start = P.total_comm().sent;
|
|
auto stats = P.total_comm();
|
|
auto& extra_player = P;
|
|
|
|
auto& protocol = proc.protocol;
|
|
auto& MCp = proc.MC;
|
|
typedef T<typename P256Element::Scalar> pShare;
|
|
typedef T<P256Element> cShare;
|
|
vector<pShare> inv_ks;
|
|
vector<cShare> secret_Rs;
|
|
prep.buffer_triples();
|
|
vector<pShare> bs, cs;
|
|
for (int i = 0; i < buffer_size; i++)
|
|
{
|
|
pShare a, b, c;
|
|
prep.get_three(DATA_TRIPLE, a, b, c);
|
|
inv_ks.push_back(a);
|
|
bs.push_back(b);
|
|
cs.push_back(c);
|
|
}
|
|
vector<P256Element::Scalar> cs_opened;
|
|
MCp.POpen_Begin(cs_opened, cs, extra_player);
|
|
if (opts.fewer_rounds)
|
|
secret_Rs.insert(secret_Rs.begin(), bs.begin(), bs.end());
|
|
else
|
|
{
|
|
MCp.POpen_End(cs_opened, cs, extra_player);
|
|
for (int i = 0; i < buffer_size; i++)
|
|
secret_Rs.push_back(bs[i] / cs_opened[i]);
|
|
}
|
|
vector<P256Element> opened_Rs(buffer_size);
|
|
typename cShare::Direct_MC MCc(MCp.get_alphai());
|
|
if (not opts.R_after_msg)
|
|
MCc.POpen_Begin(opened_Rs, secret_Rs, extra_player);
|
|
if (prep_mul)
|
|
{
|
|
for (int i = 0; i < buffer_size; i++)
|
|
protocol.prepare_mul(inv_ks[i], sk);
|
|
protocol.start_exchange();
|
|
}
|
|
if (opts.fewer_rounds)
|
|
MCp.POpen_End(cs_opened, cs, extra_player);
|
|
if (not opts.R_after_msg)
|
|
{
|
|
MCc.POpen_End(opened_Rs, secret_Rs, extra_player);
|
|
if (opts.fewer_rounds)
|
|
for (int i = 0; i < buffer_size; i++)
|
|
opened_Rs[i] /= cs_opened[i];
|
|
}
|
|
if (prep_mul)
|
|
protocol.stop_exchange();
|
|
if (opts.check_open)
|
|
MCc.Check(extra_player);
|
|
if (opts.check_open or opts.check_beaver_open)
|
|
MCp.Check(extra_player);
|
|
for (int i = 0; i < buffer_size; i++)
|
|
{
|
|
tuples.push_back(
|
|
{ inv_ks[i], prep_mul ? protocol.finalize_mul() : pShare(),
|
|
cs_opened[i], secret_Rs[i], opened_Rs[i] });
|
|
}
|
|
timer.stop();
|
|
cout << "Generated " << buffer_size << " tuples in " << timer.elapsed()
|
|
<< " seconds, throughput " << buffer_size / timer.elapsed() << ", "
|
|
<< 1e-3 * (P.total_comm().sent - start) / buffer_size
|
|
<< " kbytes per tuple" << endl;
|
|
(P.total_comm() - stats).print(true);
|
|
}
|
|
|
|
template<template<class U> class T>
|
|
void check(vector<EcTuple<T>>& tuples, T<P256Element::Scalar> sk,
|
|
P256Element::Scalar alphai, Player& P)
|
|
{
|
|
typename T<P256Element::Scalar>::MAC_Check MC(alphai);
|
|
auto open_sk = MC.open(sk, P);
|
|
for (auto& tuple : tuples)
|
|
{
|
|
auto inv_k = MC.open(tuple.a, P);
|
|
auto k = inv_k.invert();
|
|
assert(open_sk * inv_k == MC.open(tuple.b, P));
|
|
assert(tuple.R == k);
|
|
}
|
|
MC.Check(P);
|
|
}
|
|
|
|
#endif /* ECDSA_PREPROCESSING_HPP_ */
|