BOOL ObliviouslySend(CBitVector& X1, CBitVector& X2, int numOTs, int bitlength,
snd_ot_flavor stype, rec_ot_flavor rtype, crypto* crypt)
{
bool success = FALSE;
m_vSocket->reset_bytes_sent();
m_vSocket->reset_bytes_received();
int nSndVals = 2; //Perform 1-out-of-2 OT
timeval ot_begin, ot_end;
gettimeofday(&ot_begin, NULL);
// Execute OT sender routine
success = sender->send((uint32_t) numOTs, (uint32_t) bitlength, X1, X2, stype, rtype, m_nNumOTThreads, m_fMaskFct);
gettimeofday(&ot_end, NULL);
#ifndef BATCH
printf("Time spent:\t%f\n", getMillies(ot_begin, ot_end) + rndgentime);
cout << "Sent:\t\t" << m_vSocket->get_bytes_sent() << " bytes" << endl;
cout << "Received:\t" << m_vSocket->get_bytes_received() <<" bytes" << endl;
#else
cout << getMillies(ot_begin, ot_end) + rndgentime << "\t" << m_vSocket->get_bytes_sent() << "\t" << m_vSocket->get_bytes_received() << endl;
#endif
return success;
}
BOOL ObliviouslyReceive(CBitVector& choices, CBitVector& ret, int numOTs, int bitlength,
snd_ot_flavor stype, rec_ot_flavor rtype, crypto* crypt)
{
bool success = FALSE;
m_vSocket->reset_bytes_sent();
m_vSocket->reset_bytes_received();
timeval ot_begin, ot_end;
gettimeofday(&ot_begin, NULL);
// Execute OT receiver routine
success = receiver->receive(numOTs, bitlength, choices, ret, stype, rtype, m_nNumOTThreads, m_fMaskFct);
gettimeofday(&ot_end, NULL);
#ifndef BATCH
printf("Time spent:\t%f\n", getMillies(ot_begin, ot_end) + rndgentime);
cout << "Sent:\t\t" << m_vSocket->get_bytes_sent() << " bytes" << endl;
cout << "Received:\t" << m_vSocket->get_bytes_received() <<" bytes" << endl;
#else
cout << getMillies(ot_begin, ot_end) + rndgentime << "\t" << m_vSocket->get_bytes_sent() << "\t" << m_vSocket->get_bytes_received() << endl;
#endif
return success;
}
void OTExtSnd::ComputePKBaseOTs() {
channel* chan = new channel(0, m_cRcvThread, m_cSndThread);
uint8_t* pBuf = (uint8_t*) malloc(m_cCrypt->get_hash_bytes() * m_nBaseOTs);
uint8_t* keyBuf = (uint8_t*) malloc(m_cCrypt->get_aes_key_bytes() * m_nBaseOTs);
timeval np_begin, np_end;
gettimeofday(&np_begin, NULL);
m_cBaseOT->Receiver(m_nSndVals, m_nBaseOTs, m_vU, chan, pBuf);
gettimeofday(&np_end, NULL);
#ifndef BATCH
printf("Time for performing the base-OTs: %f seconds\n", getMillies(np_begin, np_end));
#else
cout << getMillies(np_begin, np_end) << "\t";
#endif
//Key expansion
uint8_t* pBufIdx = pBuf;
for(int i=0; i<m_nBaseOTs; i++ )
{
memcpy(keyBuf + i * m_cCrypt->get_aes_key_bytes(), pBufIdx, m_cCrypt->get_aes_key_bytes());
pBufIdx+=m_cCrypt->get_hash_bytes();
}
free(pBuf);
InitPRFKeys(keyBuf, m_nBaseOTs);
free(keyBuf);
chan->synchronize_end();
delete chan;
}
void BaseMPSIParty::runAndLog() {
BaseMPSIResult result;
timeval t_start, t_end;
gettimeofday(&t_start, NULL);
std::string iface = "eth0";
if (m_isLocalHost) {
iface = "lo";
}
uint32_t txBefore = getBytes("tx",iface.c_str());
result.intersectionSize = run();
gettimeofday(&t_end, NULL);
result.finalTime = getMillies(t_start,t_end);
result.txFinal = getBytes("tx",iface.c_str())-txBefore;
PRINT_PARTY(m_partyId) << "Send the following values: " << result.finalTime << ", " << result.txFinal << ", " << result.intersectionSize << std::endl;
m_serverSocket.Send(reinterpret_cast<byte *>(&result), sizeof(BaseMPSIResult));
m_serverSocket.Send(reinterpret_cast<byte *>(&sInfo), sizeof(SendingInfo));
}
int32_t psi_demonstrator(int32_t argc, char** argv) {
double epsilon=1.2;
uint64_t bytes_sent=0, bytes_received=0, mbfac;
uint32_t nelements=0, elebytelen=16, symsecbits=128, intersect_size = 0, i, j, ntasks=1,
pnelements, *elebytelens, *res_bytelens, nclients = 2;
uint16_t port=7766;
uint8_t **elements, **intersection;
bool detailed_timings=false;
string address="127.0.0.1";
timeval t_start, t_end;
vector<CSocket> sockfd(ntasks);
string filename;
role_type role = (role_type) 0;
psi_prot protocol;
mbfac=1024*1024;
read_psi_demo_options(&argc, &argv, &role, &protocol, &filename, &address, &nelements, &detailed_timings);
if(role == FOLLOWER) {
if(protocol == TTP) {
sockfd.resize(nclients);
listen(address.c_str(), port, sockfd.data(), nclients);
}
else
listen(address.c_str(), port, sockfd.data(), ntasks);
} else {
for(i = 0; i < ntasks; i++)
connect(address.c_str(), port, sockfd[i]);
}
gettimeofday(&t_start, NULL);
//read in files and get elements and byte-length from there
read_elements(&elements, &elebytelens, &nelements, filename);
if(detailed_timings) {
gettimeofday(&t_end, NULL);
}
if(protocol != TTP)
pnelements = exchange_information(nelements, elebytelen, symsecbits, ntasks, protocol, sockfd[0]);
//cout << "Performing private set-intersection between " << nelements << " and " << pnelements << " element sets" << endl;
if(detailed_timings) {
cout << "Time for reading elements:\t" << fixed << std::setprecision(2) << getMillies(t_start, t_end)/1000 << " s" << endl;
}
crypto crypto(symsecbits);//, (uint8_t*) const_seed);
switch(protocol) {
case NAIVE:
intersect_size = naivepsi(role, nelements, pnelements, elebytelens, elements, &intersection, &res_bytelens,
&crypto, sockfd.data(), ntasks);
break;
case TTP:
intersect_size = ttppsi(role, nelements, elebytelens, elements, &intersection, &res_bytelens,
&crypto, sockfd.data(), ntasks);
break;
case DH_ECC:
intersect_size = dhpsi(role, nelements, pnelements, elebytelens, elements, &intersection, &res_bytelens, &crypto,
sockfd.data(), ntasks);
break;
case OT_PSI:
intersect_size = otpsi(role, nelements, pnelements, elebytelens, elements, &intersection, &res_bytelens,
&crypto, sockfd.data(), ntasks, epsilon, detailed_timings);
break;
default:
intersect_size = otpsi(role, nelements, pnelements, elebytelens, elements, &intersection, &res_bytelens,
&crypto, sockfd.data(), ntasks, epsilon, detailed_timings);
break;
}
gettimeofday(&t_end, NULL);
if(role == LEADER) {
cout << "Computation finished. Found " << intersect_size << " intersecting elements:" << endl;
if(!detailed_timings) {
for(i = 0; i < intersect_size; i++) {
//cout << i << ": \t";
for(j = 0; j < res_bytelens[i]; j++) {
cout << intersection[i][j];
}
cout << endl;
}
}
for(i = 0; i < intersect_size; i++) {
free(intersection[i]);
}
if(intersect_size > 0)
free(res_bytelens);
}
for(i = 0; i < sockfd.size(); i++) {
bytes_sent += sockfd[i].get_bytes_sent();
bytes_received += sockfd[i].get_bytes_received();
}
if(detailed_timings) {
cout << "Required time:\t" << fixed << std::setprecision(1) << getMillies(t_start, t_end)/1000 << " s" << endl;
cout << "Data sent:\t" << ((double)bytes_sent)/mbfac << " MB" << endl;
cout << "Data received:\t" << ((double)bytes_received)/mbfac << " MB" << endl;
}
for(i = 0; i < nelements; i++)
free(elements[i]);
free(elements);
free(elebytelens);
return 1;
}
BOOL ALSZOTExtRec::receiver_routine(uint32_t id, uint64_t myNumOTs) {
uint64_t myStartPos = id * myNumOTs;
uint64_t wd_size_bits = m_nBlockSizeBits;
uint64_t internal_numOTs = std::min(myNumOTs + myStartPos, m_nOTs) - myStartPos;
uint64_t lim = myStartPos + internal_numOTs;
uint64_t processedOTBlocks = std::min(num_ot_blocks, ceil_divide(internal_numOTs, wd_size_bits));
uint64_t OTsPerIteration = processedOTBlocks * wd_size_bits;
uint64_t OTwindow = num_ot_blocks * wd_size_bits;
uint64_t** rndmat;
bool use_mat_chan = (m_eSndOTFlav == Snd_GC_OT || m_bUseMinEntCorRob);
uint32_t nchans = 2;
if(use_mat_chan) {
nchans = 3;
}
channel* ot_chan = new channel(OT_BASE_CHANNEL+nchans*id, m_cRcvThread, m_cSndThread);
channel* check_chan = new channel(OT_BASE_CHANNEL+nchans*id+1, m_cRcvThread, m_cSndThread);
channel* mat_chan;
if(use_mat_chan) {
mat_chan = new channel(nchans*id+2, m_cRcvThread, m_cSndThread);
}
// A temporary part of the T matrix
CBitVector T(wd_size_bits * OTsPerIteration);
// The send buffer
CBitVector vSnd(m_nBaseOTs * OTsPerIteration);
// A temporary buffer that stores the resulting seeds from the hash buffer
//TODO: Check for some maximum size
CBitVector seedbuf(OTwindow * m_cCrypt->get_aes_key_bytes() * 8);
uint64_t otid = myStartPos;
std::queue<alsz_rcv_check_t> check_buf;
std::queue<mask_block*> mask_queue;
CBitVector maskbuf;
maskbuf.Create(m_nBitLength * OTwindow);
//these two values are only required for the min entropy correlation robustness assumption
alsz_rcv_check_t check_tmp;
CBitVector Ttmp(wd_size_bits * OTsPerIteration);
OT_AES_KEY_CTX* tmp_base_keys;
uint64_t base_ot_block_ctr = otid / (myNumOTs);
//TODO only do when successfull checks
if(m_eSndOTFlav == Snd_GC_OT) {
initRndMatrix(&rndmat, m_nBitLength, m_nBaseOTs);
}
#ifdef OTTiming
double totalMtxTime = 0, totalTnsTime = 0, totalHshTime = 0, totalRcvTime = 0, totalSndTime = 0,
totalChkTime = 0, totalMaskTime = 0, totalEnqueueTime = 0, totalOutputSetTime = 0;
timespec tempStart, tempEnd;
#endif
while (otid < lim) {
processedOTBlocks = std::min(num_ot_blocks, ceil_divide(lim - otid, wd_size_bits));
OTsPerIteration = processedOTBlocks * wd_size_bits;
//nSize = bits_in_bytes(m_nBaseOTs * OTsPerIteration);
tmp_base_keys = m_tBaseOTKeys[base_ot_block_ctr];
//m_tBaseOTQ.pop();
#ifdef OTTiming
clock_gettime(CLOCK_MONOTONIC, &tempStart);
#endif
BuildMatrices(&T, &vSnd, otid, processedOTBlocks, tmp_base_keys);
#ifdef OTTiming
clock_gettime(CLOCK_MONOTONIC, &tempEnd);
totalMtxTime += getMillies(tempStart, tempEnd);
clock_gettime(CLOCK_MONOTONIC, &tempStart);
#endif
check_buf.push(EnqueueSeed(T.GetArr(), vSnd.GetArr(), otid, processedOTBlocks));
#ifdef OTTiming
clock_gettime(CLOCK_MONOTONIC, &tempEnd);
totalEnqueueTime += getMillies(tempStart, tempEnd);
clock_gettime(CLOCK_MONOTONIC, &tempStart);
#endif
MaskBaseOTs(&T, &vSnd, otid, processedOTBlocks);
#ifdef OTTiming
clock_gettime(CLOCK_MONOTONIC, &tempEnd);
totalMaskTime += getMillies(tempStart, tempEnd);
clock_gettime(CLOCK_MONOTONIC, &tempStart);
#endif
SendMasks(&vSnd, ot_chan, otid, OTsPerIteration);
//ot_chan->send_id_len(vSnd.GetArr(), nSize, otid, OTsPerIteration);
#ifdef OTTiming
clock_gettime(CLOCK_MONOTONIC, &tempEnd);
totalSndTime += getMillies(tempStart, tempEnd);
clock_gettime(CLOCK_MONOTONIC, &tempStart);
#endif
ReceiveAndFillMatrix(rndmat, mat_chan);
if(!m_bUseMinEntCorRob) {
T.Transpose(wd_size_bits, OTsPerIteration);
#ifdef OTTiming
clock_gettime(CLOCK_MONOTONIC, &tempEnd);
totalTnsTime += getMillies(tempStart, tempEnd);
clock_gettime(CLOCK_MONOTONIC, &tempStart);
#endif
HashValues(&T, &seedbuf, &maskbuf, otid, std::min(lim - otid, OTsPerIteration), rndmat);
#ifdef OTTiming
clock_gettime(CLOCK_MONOTONIC, &tempEnd);
totalHshTime += getMillies(tempStart, tempEnd);
clock_gettime(CLOCK_MONOTONIC, &tempStart);
#endif
}
if(check_chan->data_available()) {
if(m_bUseMinEntCorRob) {
check_tmp = check_buf.front();
Ttmp.Copy(check_tmp.T0, 0, check_tmp.numblocks * m_nBlockSizeBytes);
}
ComputeOWF(&check_buf, check_chan);
if(m_bUseMinEntCorRob) {
ReceiveAndXORCorRobVector(&Ttmp, check_tmp.numblocks * wd_size_bits, mat_chan);
Ttmp.Transpose(wd_size_bits, OTsPerIteration);
HashValues(&Ttmp, &seedbuf, &maskbuf, check_tmp.otid, std::min(lim - check_tmp.otid, check_tmp.numblocks * wd_size_bits), rndmat);
}
#ifdef OTTiming
clock_gettime(CLOCK_MONOTONIC, &tempEnd);
totalChkTime += getMillies(tempStart, tempEnd);
clock_gettime(CLOCK_MONOTONIC, &tempStart);
#endif
}
SetOutput(&maskbuf, otid, OTsPerIteration, &mask_queue, ot_chan);
otid += std::min(lim - otid, OTsPerIteration);
base_ot_block_ctr++;
#ifdef OTTiming
clock_gettime(CLOCK_MONOTONIC, &tempEnd);
totalOutputSetTime += getMillies(tempStart, tempEnd);
#endif
//free(tmp_base_keys);
//free(tmp_baseots);
vSnd.Reset();
T.Reset();
}
while(!check_buf.empty()) {
if(check_chan->data_available()) {
if(m_bUseMinEntCorRob) {
check_tmp = check_buf.front();
Ttmp.Copy(check_tmp.T0, 0, check_tmp.numblocks * m_nBlockSizeBytes);
}
#ifdef OTTiming
clock_gettime(CLOCK_MONOTONIC, &tempStart);
#endif
ComputeOWF(&check_buf, check_chan);
#ifdef OTTiming
clock_gettime(CLOCK_MONOTONIC, &tempEnd);
totalChkTime += getMillies(tempStart, tempEnd);
#endif
if(m_bUseMinEntCorRob) {
ReceiveAndXORCorRobVector(&Ttmp, check_tmp.numblocks * wd_size_bits, mat_chan);
Ttmp.Transpose(wd_size_bits, OTsPerIteration);
HashValues(&Ttmp, &seedbuf, &maskbuf, check_tmp.otid, std::min(lim - check_tmp.otid, check_tmp.numblocks * wd_size_bits), rndmat);
}
}
}
if(m_eSndOTFlav != Snd_R_OT) {
//finevent->Wait();
#ifdef ABY_OT
while(!(mask_queue.empty())) {
#else
while(ot_chan->is_alive() && !(mask_queue.empty())) {
#endif
#ifdef OTTiming
clock_gettime(CLOCK_MONOTONIC, &tempStart);
#endif
ReceiveAndUnMask(ot_chan, &mask_queue);
#ifdef OTTiming
clock_gettime(CLOCK_MONOTONIC, &tempEnd);
totalOutputSetTime += getMillies(tempStart, tempEnd);
#endif
}
}
ot_chan->synchronize_end();
check_chan->synchronize_end();
delete ot_chan;
delete check_chan;
T.delCBitVector();
vSnd.delCBitVector();
seedbuf.delCBitVector();
maskbuf.delCBitVector();
Ttmp.delCBitVector();
if(use_mat_chan) {
mat_chan->synchronize_end();
delete mat_chan;
}
if(m_eSndOTFlav==Snd_GC_OT) {
freeRndMatrix(rndmat, m_nBaseOTs);
}
#ifdef OTTiming
std::cout << "Receiver time benchmark for performing " << internal_numOTs << " OTs on " << m_nBitLength << " bit strings" << std::endl;
std::cout << "Time needed for: " << std::endl;
std::cout << "\t Matrix Generation:\t" << totalMtxTime << " ms" << std::endl;
std::cout << "\t Enqueuing Seeds:\t" << totalEnqueueTime << " ms" << std::endl;
std::cout << "\t Base OT Masking:\t" << totalMaskTime << " ms" << std::endl;
std::cout << "\t Sending Matrix:\t" << totalSndTime << " ms" << std::endl;
std::cout << "\t Transposing Matrix:\t" << totalTnsTime << " ms" << std::endl;
std::cout << "\t Hashing Matrix:\t" << totalHshTime << " ms" << std::endl;
std::cout << "\t Receiving Values:\t" << totalRcvTime << " ms" << std::endl;
std::cout << "\t Checking OWF: \t" << totalChkTime << " ms" << std::endl;
std::cout << "\t Setting Output:\t" << totalOutputSetTime << " ms" << std::endl;
#endif
return TRUE;
}
void ALSZOTExtRec::ReceiveAndFillMatrix(uint64_t** rndmat, channel* mat_chan) {
if(m_eSndOTFlav == Snd_GC_OT) {
uint8_t* rnd_seed = mat_chan->blocking_receive();
//initRndMatrix(&rndmat, m_nBitLength, m_nBaseOTs);
fillRndMatrix(rnd_seed, rndmat, m_nBitLength, m_nBaseOTs, m_cCrypt);
free(rnd_seed);
}
}
alsz_rcv_check_t ALSZOTExtRec::EnqueueSeed(uint8_t* T0, uint8_t* T1, uint64_t otid, uint64_t numblocks) {
uint64_t expseedbytelen = m_nBaseOTs * numblocks * m_nBlockSizeBytes;
alsz_rcv_check_t seedstr;
seedstr.otid = otid;
seedstr.numblocks = numblocks;
seedstr.T0 = (uint8_t*) malloc(expseedbytelen);
seedstr.T1 = (uint8_t*) malloc(expseedbytelen);
memcpy(seedstr.T0, T0, expseedbytelen);
memcpy(seedstr.T1, T1, expseedbytelen);
return seedstr;
}
BOOL NNOBOTExtSnd::sender_routine(uint32_t id, uint64_t myNumOTs) {
uint64_t myStartPos = id * myNumOTs;
uint64_t wd_size_bits = m_nBlockSizeBits;
uint64_t processedOTBlocks = min((uint64_t) NUMOTBLOCKS, ceil_divide(myNumOTs, wd_size_bits));
uint64_t OTsPerIteration = processedOTBlocks * wd_size_bits;
uint64_t tmpctr, tmpotlen;
uint32_t nchans = 2;
bool use_mat_chan = (m_eSndOTFlav == Snd_GC_OT || m_bUseMinEntCorRob);
if(use_mat_chan) {
nchans = 3;
}
channel* ot_chan = new channel(nchans*id, m_cRcvThread, m_cSndThread);
channel* check_chan = new channel(nchans*id + 1, m_cRcvThread, m_cSndThread);
channel* mat_chan;
if(use_mat_chan) {
mat_chan = new channel(nchans*id+2, m_cRcvThread, m_cSndThread);
}
myNumOTs = min(myNumOTs + myStartPos, m_nOTs) - myStartPos;
uint64_t lim = myStartPos + myNumOTs;
uint64_t** rndmat;
// The vector with the received bits
CBitVector vRcv(m_nBaseOTs * OTsPerIteration);
vRcv.Reset();
// Holds the reply that is sent back to the receiver
uint32_t numsndvals = 2;
CBitVector* vSnd;
CBitVector* seedbuf = new CBitVector[m_nSndVals];
for (uint32_t u = 0; u < m_nSndVals; u++)
seedbuf[u].Create(OTsPerIteration * m_cCrypt->get_aes_key_bytes() * 8);
#ifdef ZDEBUG
cout << "seedbuf size = " <<OTsPerIteration * AES_KEY_BITS << endl;
#endif
vSnd = new CBitVector[numsndvals];
for (uint32_t i = 0; i < numsndvals; i++) {
vSnd[i].Create(OTsPerIteration * m_nBitLength);
}
// Contains the parts of the V matrix
CBitVector Q(wd_size_bits * OTsPerIteration);
mask_buf_t tmpmaskbuf;
uint64_t OT_ptr = myStartPos;
uint8_t *rcvbuftmpptr, *rcvbufptr;
queue<nnob_snd_check_t> check_queue;
queue<mask_buf_t> mask_queue;
uint32_t startpos = 0;
if(m_eRecOTFlav==Rec_R_OT) {
startpos = 1;
}
if(m_eSndOTFlav == Snd_GC_OT) {
initRndMatrix(&rndmat, m_nBitLength, m_nBaseOTs);
}
#ifdef OTTiming
double totalMtxTime = 0, totalTnsTime = 0, totalHshTime = 0, totalRcvTime = 0, totalSndTime = 0, totalUnMaskTime = 0,
totalHashCheckTime = 0;
timeval tempStart, tempEnd;
#endif
while (OT_ptr < lim) //do while there are still transfers missing
{
processedOTBlocks = min((uint64_t) NUMOTBLOCKS, ceil_divide(lim - OT_ptr, wd_size_bits));
OTsPerIteration = processedOTBlocks * wd_size_bits;
#ifdef ZDEBUG
cout << "Processing block " << nProgress << " with length: " << OTsPerIteration << ", and limit: " << lim << endl;
#endif
#ifdef OTTiming
gettimeofday(&tempStart, NULL);
#endif
rcvbufptr = ot_chan->blocking_receive_id_len(&rcvbuftmpptr, &tmpctr, &tmpotlen);
//vRcv.AttachBuf(rcvbuftmpptr, bits_in_bytes(m_nBaseOTs * OTsPerIteration));
vRcv.SetBytes(rcvbuftmpptr, bits_in_bytes(OTsPerIteration*startpos), bits_in_bytes((m_nBaseOTs-startpos)*OTsPerIteration));
free(rcvbufptr);
//vRcv.PrintHex();
#ifdef OTTiming
gettimeofday(&tempEnd, NULL);
totalRcvTime += getMillies(tempStart, tempEnd);
gettimeofday(&tempStart, NULL);
#endif
BuildQMatrix(Q, OT_ptr, processedOTBlocks);
#ifdef OTTiming
gettimeofday(&tempEnd, NULL);
totalMtxTime += getMillies(tempStart, tempEnd);
gettimeofday(&tempStart, NULL);
#endif
check_queue.push(UpdateCheckBuf(Q.GetArr(), vRcv.GetArr(), OT_ptr, processedOTBlocks, check_chan));
FillAndSendRandomMatrix(rndmat, mat_chan);
#ifdef OTTiming
gettimeofday(&tempEnd, NULL);
totalHashCheckTime += getMillies(tempStart, tempEnd);
gettimeofday(&tempStart, NULL);
#endif
UnMaskBaseOTs(Q, vRcv, processedOTBlocks);
GenerateSendAndXORCorRobVector(Q, OTsPerIteration, mat_chan);
#ifdef OTTiming
gettimeofday(&tempEnd, NULL);
totalUnMaskTime += getMillies(tempStart, tempEnd);
gettimeofday(&tempStart, NULL);
#endif
Q.Transpose(wd_size_bits, OTsPerIteration);
#ifdef OTTiming
gettimeofday(&tempEnd, NULL);
totalTnsTime += getMillies(tempStart, tempEnd);
gettimeofday(&tempStart, NULL);
#endif
HashValues(Q, seedbuf, vSnd, OT_ptr, min(lim - OT_ptr, OTsPerIteration), rndmat);
#ifdef OTTiming
gettimeofday(&tempEnd, NULL);
totalHshTime += getMillies(tempStart, tempEnd);
gettimeofday(&tempStart, NULL);
#endif
//TODO: outsource into method
tmpmaskbuf.otid = OT_ptr;
tmpmaskbuf.otlen = min(lim - OT_ptr, OTsPerIteration);
tmpmaskbuf.maskbuf = new CBitVector[numsndvals];
for(uint32_t i = 0; i < numsndvals; i++)
tmpmaskbuf.maskbuf[i].Copy(vSnd[i]);
mask_queue.push(tmpmaskbuf);
if(check_chan->data_available()) {
assert(CheckConsistency(&check_queue, check_chan));//TODO assert
tmpmaskbuf = mask_queue.front();
mask_queue.pop();
MaskAndSend(tmpmaskbuf.maskbuf, tmpmaskbuf.otid, tmpmaskbuf.otlen, ot_chan);
}
#ifdef OTTiming
gettimeofday(&tempEnd, NULL);
totalSndTime += getMillies(tempStart, tempEnd);
#endif
OT_ptr += min(lim - OT_ptr, OTsPerIteration);
Q.Reset();
//free(rcvbufptr);
}
while(!check_queue.empty()) {
if(check_chan->data_available()) {
assert(CheckConsistency(&check_queue, check_chan));//TODO assert
tmpmaskbuf = mask_queue.front();
mask_queue.pop();
MaskAndSend(tmpmaskbuf.maskbuf, tmpmaskbuf.otid, tmpmaskbuf.otlen, ot_chan);
}
}
//vRcv.delCBitVector();
ot_chan->synchronize_end();
check_chan->synchronize_end();
Q.delCBitVector();
for (uint32_t u = 0; u < m_nSndVals; u++)
seedbuf[u].delCBitVector();
for (uint32_t i = 0; i < numsndvals; i++)
vSnd[i].delCBitVector();
if (numsndvals > 0)
free(vSnd);
if(use_mat_chan) {
mat_chan->synchronize_end();
}
if(m_eSndOTFlav == Snd_GC_OT) {
freeRndMatrix(rndmat, m_nBaseOTs);
}
#ifdef OTTiming
cout << "Sender time benchmark for performing " << myNumOTs << " OTs on " << m_nBitLength << " bit strings" << endl;
cout << "Time needed for: " << endl;
cout << "\t Matrix Generation:\t" << totalMtxTime << " ms" << endl;
cout << "\t BaseOT Unmasking:\t" << totalUnMaskTime << " ms" << endl;
cout << "\t Check Hashing:\t" << totalHashCheckTime << " ms" << endl;
cout << "\t Sending Matrix:\t" << totalSndTime << " ms" << endl;
cout << "\t Transposing Matrix:\t" << totalTnsTime << " ms" << endl;
cout << "\t Hashing Matrix:\t" << totalHshTime << " ms" << endl;
cout << "\t Receiving Values:\t" << totalRcvTime << " ms" << endl;
#endif
delete ot_chan;
delete check_chan;
return TRUE;
}
BOOL KKOTExtSnd::sender_routine(uint32_t id, uint64_t myNumOTs) {
uint32_t choicecodebitlen = ceil_log2(m_nSndVals);
uint64_t myStartPos = id * myNumOTs;
uint64_t myStartPos1ooN = ceil_divide(myStartPos, choicecodebitlen);
uint64_t wd_size_bits = m_nBlockSizeBits;
uint64_t processedOTBlocks =
min((uint64_t)NUMOTBLOCKS, ceil_divide(myNumOTs, wd_size_bits));
uint64_t OTsPerIteration = processedOTBlocks * wd_size_bits;
channel *chan = new channel(id, m_cRcvThread, m_cSndThread);
uint64_t tmpctr, tmpotlen;
uint64_t **rndmat;
uint64_t processedOTs;
myNumOTs = min(myNumOTs + myStartPos, m_nOTs) - myStartPos;
// TODO some re-formating of myNumOTs due to 1ooN OT
uint64_t lim = myStartPos1ooN + ceil_divide(myNumOTs, choicecodebitlen);
if (myStartPos1ooN * choicecodebitlen > m_nOTs) {
cerr << "Thread " << id
<< " not doing any work to align to window size " << endl;
return true;
}
// The vector with the received bits
#ifdef GENERATE_T_EXPLICITELY
CBitVector vRcv(2 * m_nBaseOTs * OTsPerIteration);
#else
CBitVector vRcv(m_nBaseOTs * OTsPerIteration);
#endif
// Holds the reply that is sent back to the receiver
CBitVector *vSnd;
CBitVector *seedbuf = new CBitVector[m_nSndVals];
for (uint32_t u = 0; u < m_nSndVals; u++) {
seedbuf[u].Create(OTsPerIteration * m_cCrypt->get_aes_key_bytes() * 8);
}
#ifdef ZDEBUG
cout << "seedbuf size = " << OTsPerIteration *AES_KEY_BITS << endl;
#endif
vSnd = new CBitVector[m_nSndVals];
for (uint32_t i = 0; i < m_nSndVals; i++) {
vSnd[i].Create(OTsPerIteration * choicecodebitlen * m_nBitLength);
}
// Contains the parts of the V matrix
CBitVector Q(wd_size_bits * OTsPerIteration);
uint64_t otid = myStartPos1ooN;
uint8_t *rcvbuftmpptr, *rcvbufptr;
#ifdef OTTiming
double totalMtxTime = 0, totalTnsTime = 0, totalHshTime = 0,
totalRcvTime = 0, totalSndTime = 0, totalUnMaskTime = 0;
timeval tempStart, tempEnd;
#endif
if (m_eSndOTFlav == Snd_GC_OT) {
uint8_t *rnd_seed = (uint8_t *)malloc(m_nSymSecParam);
m_cCrypt->gen_rnd(rnd_seed, m_nSymSecParam);
chan->send(rnd_seed, m_nSymSecParam);
initRndMatrix(&rndmat, m_nBitLength, m_nBaseOTs);
fillRndMatrix(rnd_seed, rndmat, m_nBitLength, m_nBaseOTs, m_cCrypt);
free(rnd_seed);
}
while (otid < lim) // do while there are still transfers missing
{
processedOTBlocks =
min((uint64_t)NUMOTBLOCKS, ceil_divide(lim - otid, wd_size_bits));
OTsPerIteration = processedOTBlocks * wd_size_bits;
processedOTs = min(lim - otid, OTsPerIteration);
#ifdef ZDEBUG
cout << "Processing block " << nProgress
<< " with length: " << OTsPerIteration << ", and limit: " << lim
<< endl;
#endif
#ifdef OTTiming
gettimeofday(&tempStart, NULL);
#endif
ReceiveMasks(vRcv, chan, OTsPerIteration);
#ifdef OTTiming
gettimeofday(&tempEnd, NULL);
totalRcvTime += getMillies(tempStart, tempEnd);
gettimeofday(&tempStart, NULL);
#endif
BuildQMatrix(Q, otid, processedOTBlocks);
#ifdef OTTiming
gettimeofday(&tempEnd, NULL);
totalMtxTime += getMillies(tempStart, tempEnd);
gettimeofday(&tempStart, NULL);
#endif
UnMaskBaseOTs(Q, vRcv, processedOTBlocks);
#ifdef OTTiming
gettimeofday(&tempEnd, NULL);
totalUnMaskTime += getMillies(tempStart, tempEnd);
gettimeofday(&tempStart, NULL);
#endif
Q.Transpose(wd_size_bits, OTsPerIteration);
#ifdef OTTiming
gettimeofday(&tempEnd, NULL);
totalTnsTime += getMillies(tempStart, tempEnd);
gettimeofday(&tempStart, NULL);
#endif
KKHashValues(Q, seedbuf, vSnd, otid, processedOTs, rndmat);
#ifdef OTTiming
gettimeofday(&tempEnd, NULL);
totalHshTime += getMillies(tempStart, tempEnd);
gettimeofday(&tempStart, NULL);
#endif
KKMaskAndSend(vSnd, otid, processedOTs, chan);
#ifdef OTTiming
gettimeofday(&tempEnd, NULL);
totalSndTime += getMillies(tempStart, tempEnd);
#endif
otid += processedOTs;
Q.Reset();
}
vRcv.delCBitVector();
chan->synchronize_end();
Q.delCBitVector();
for (uint32_t i = 0; i < m_nSndVals; i++) {
vSnd[i].delCBitVector();
}
delete vSnd;
if (m_eSndOTFlav == Snd_GC_OT) {
freeRndMatrix(rndmat, m_nBaseOTs);
}
#ifdef OTTiming
cout << "Sender time benchmark for performing " << myNumOTs << " OTs ("
<< lim - myStartPos1ooN << " 1ooN) on " << m_nBitLength
<< " bit strings" << endl;
cout << "Time needed for: " << endl;
cout << "\t Matrix Generation:\t" << totalMtxTime << " ms" << endl;
cout << "\t Unmasking values:\t" << totalUnMaskTime << " ms" << endl;
cout << "\t Sending Matrix:\t" << totalSndTime << " ms" << endl;
cout << "\t Transposing Matrix:\t" << totalTnsTime << " ms" << endl;
cout << "\t Hashing Matrix:\t" << totalHshTime << " ms" << endl;
cout << "\t Receiving Values:\t" << totalRcvTime << " ms" << endl;
#endif
delete chan;
return TRUE;
}
BOOL NNOBOTExtRec::receiver_routine(uint32_t id, uint64_t myNumOTs) {
uint64_t myStartPos = id * myNumOTs;
uint64_t wd_size_bits = m_nBlockSizeBits;
myNumOTs = min(myNumOTs + myStartPos, m_nOTs) - myStartPos;
uint64_t lim = myStartPos + myNumOTs;
uint64_t processedOTBlocks = min((uint64_t) NUMOTBLOCKS, ceil_divide(myNumOTs, wd_size_bits));
uint64_t OTsPerIteration = processedOTBlocks * wd_size_bits;
uint64_t OTwindow = NUMOTBLOCKS * wd_size_bits;
uint64_t** rndmat;
bool use_mat_chan = (m_eSndOTFlav == Snd_GC_OT || m_bUseMinEntCorRob);
uint32_t nchans = 2;
if(use_mat_chan) {
nchans = 3;
}
channel* ot_chan = new channel(nchans*id, m_cRcvThread, m_cSndThread);
channel* check_chan = new channel(nchans*id+1, m_cRcvThread, m_cSndThread);
channel* mat_chan;
if(use_mat_chan) {
mat_chan = new channel(nchans*id+2, m_cRcvThread, m_cSndThread);
}
//counter variables
uint64_t numblocks = ceil_divide(myNumOTs, OTsPerIteration);
// A temporary part of the T matrix
CBitVector T(wd_size_bits * OTsPerIteration);
// The send buffer
CBitVector vSnd(m_nBaseOTs * OTsPerIteration);
// A temporary buffer that stores the resulting seeds from the hash buffer
//TODO: Check for some maximum size
CBitVector seedbuf(OTwindow * m_cCrypt->get_aes_key_bytes() * 8);
uint64_t otid = myStartPos;
queue<nnob_rcv_check_t> check_buf;
queue<mask_block*> mask_queue;
CBitVector maskbuf;
maskbuf.Create(m_nBitLength * OTwindow);
//TODO only do when successfull checks
if(m_eSndOTFlav == Snd_GC_OT) {
initRndMatrix(&rndmat, m_nBitLength, m_nBaseOTs);
}
#ifdef OTTiming
double totalMtxTime = 0, totalTnsTime = 0, totalHshTime = 0, totalRcvTime = 0, totalSndTime = 0,
totalChkTime = 0, totalMaskTime = 0, totalEnqueueTime = 0;
timeval tempStart, tempEnd;
#endif
while (otid < lim) {
processedOTBlocks = min((uint64_t) NUMOTBLOCKS, ceil_divide(lim - otid, wd_size_bits));
OTsPerIteration = processedOTBlocks * wd_size_bits;
//nSize = bits_in_bytes(m_nBaseOTs * OTsPerIteration);
#ifdef OTTiming
gettimeofday(&tempStart, NULL);
#endif
BuildMatrices(T, vSnd, otid, processedOTBlocks);
#ifdef OTTiming
gettimeofday(&tempEnd, NULL);
totalMtxTime += getMillies(tempStart, tempEnd);
gettimeofday(&tempStart, NULL);
#endif
check_buf.push(EnqueueSeed(T.GetArr(), otid, processedOTBlocks));
#ifdef OTTiming
gettimeofday(&tempEnd, NULL);
totalEnqueueTime += getMillies(tempStart, tempEnd);
gettimeofday(&tempStart, NULL);
#endif
MaskBaseOTs(T, vSnd, otid, processedOTBlocks);
#ifdef OTTiming
gettimeofday(&tempEnd, NULL);
totalMaskTime += getMillies(tempStart, tempEnd);
gettimeofday(&tempStart, NULL);
#endif
SendMasks(vSnd, ot_chan, otid, OTsPerIteration);
//ot_chan->send_id_len(vSnd.GetArr(), nSize, otid, OTsPerIteration);
#ifdef OTTiming
gettimeofday(&tempEnd, NULL);
totalSndTime += getMillies(tempStart, tempEnd);
gettimeofday(&tempStart, NULL);
#endif
ReceiveAndFillMatrix(rndmat, mat_chan);
ReceiveAndXORCorRobVector(T, OTsPerIteration, mat_chan);
T.Transpose(wd_size_bits, OTsPerIteration);
#ifdef OTTiming
gettimeofday(&tempEnd, NULL);
totalTnsTime += getMillies(tempStart, tempEnd);
gettimeofday(&tempStart, NULL);
#endif
HashValues(&T, &seedbuf, &maskbuf, otid, min(lim - otid, OTsPerIteration), rndmat);
#ifdef OTTiming
gettimeofday(&tempEnd, NULL);
totalHshTime += getMillies(tempStart, tempEnd);
gettimeofday(&tempStart, NULL);
#endif
if(check_chan->data_available()) {
ComputeOWF(&check_buf, check_chan);
}
//if(ot_chan->data_available()) {
// ReceiveAndUnMask(ot_chan);
//}
SetOutput(&maskbuf, otid, OTsPerIteration, &mask_queue, ot_chan);
otid += min(lim - otid, OTsPerIteration);
#ifdef OTTiming
gettimeofday(&tempEnd, NULL);
totalRcvTime += getMillies(tempStart, tempEnd);
#endif
vSnd.Reset();
T.Reset();
}
while(!check_buf.empty()) {
if(check_chan->data_available()) {
ComputeOWF(&check_buf, check_chan);
}
}
if(m_eSndOTFlav != Snd_R_OT) {
//finevent->Wait();
while(ot_chan->is_alive() && !(mask_queue.empty()))
ReceiveAndUnMask(ot_chan, &mask_queue);
}
ot_chan->synchronize_end();
check_chan->synchronize_end();
T.delCBitVector();
vSnd.delCBitVector();
seedbuf.delCBitVector();
maskbuf.delCBitVector();
if(use_mat_chan) {
mat_chan->synchronize_end();
}
if(m_eSndOTFlav==Snd_GC_OT) {
freeRndMatrix(rndmat, m_nBaseOTs);
}
#ifdef OTTiming
cout << "Receiver time benchmark for performing " << myNumOTs << " OTs on " << m_nBitLength << " bit strings" << endl;
cout << "Time needed for: " << endl;
cout << "\t Matrix Generation:\t" << totalMtxTime << " ms" << endl;
cout << "\t Enqueuing Seeds:\t" << totalEnqueueTime << " ms" << endl;
cout << "\t Base OT Masking:\t" << totalMaskTime << " ms" << endl;
cout << "\t Sending Matrix:\t" << totalSndTime << " ms" << endl;
cout << "\t Transposing Matrix:\t" << totalTnsTime << " ms" << endl;
cout << "\t Hashing Matrix:\t" << totalHshTime << " ms" << endl;
cout << "\t Receiving Values:\t" << totalRcvTime << " ms" << endl;
#endif
return TRUE;
}
