// Sends a transmit request to the XBee to send a message to destAddr: frame ID = fID, len is length of message[];
void XB::sendTransmitRequest(uint8_t fID, uint16_t destAddr, uint8_t options, uint16_t len, char* message) {
// constants
const uint16_t lenToData = 5;
// len is the length of the message
char payload[len + 9];
uint8_t checksum = 1 + fID + getMSB(destAddr) + getLSB(destAddr) + options;
// beginning of frame
payload[0] = FRAME_HEADER_MAGIC_BYTE;
payload[1] = getMSB(len + lenToData);
payload[2] = getLSB(len + lenToData);
payload[3] = FRAME_TRANSMIT_REQUEST; // transmit request 16-bit addr
payload[4] = fID;
payload[5] = getMSB(destAddr);
payload[6] = getLSB(destAddr);
payload[7] = options;
// data
for (uint16_t i = 0; i < len; i++) {
payload[i+8] = message[i];
checksum += message[i];
}
// checksum
payload[len + 8] = 0xff - checksum;
// send the message
for (uint16_t i = 0; i < len + 9; i++) {
serial.print(payload[i]);
}
}
int genericGate(GarbledCircuit *garbledCircuit, GarblingContext *garblingContext, int input0, int input1, int output, int *vals, int type) {
createNewWire(&(garbledCircuit->wires[output]), garblingContext, output);
GarbledGate *garbledGate = &(garbledCircuit->garbledGates[garblingContext->gateIndex]);
GarbledTable *garbledTable = &(garbledCircuit->garbledTable[garblingContext->tableIndex]);
garbledGate->id = garblingContext->gateIndex;
garbledGate->type = type;
garbledGate->input0 = input0;
garbledGate->input1 = input1;
garbledGate->output = output;
block blocks[4];
block keys[4];
long lsb0 = getLSB(garbledCircuit->wires[input0].label0);
long lsb1 = getLSB(garbledCircuit->wires[input1].label0);
block tweak;
block keyToEncrypt;
tweak = makeBlock(garblingContext->gateIndex, (long)0);
garblingContext->gateIndex++;
garblingContext->tableIndex++;
return garbledGate->id;
}
void uLCD_144::setBgColor(byte red, byte green, byte blue) {
Serial.write((byte)0x42); // set screen color
Serial.write((byte)getMSB(red, green, blue));
Serial.write((byte)getLSB(red, green, blue));
waitAck();
}
// draw pixel
void uLCD_144::drawPixel(int x, int y, byte red, byte green, byte blue) {
Serial.write(0x50);
Serial.write(x);
Serial.write(y);
Serial.write(getMSB(red, green, blue));
Serial.write(getLSB(red, green, blue));
waitAck();
}
void uLCD_144_SPE::setFGcolor(byte red, byte green, byte blue) {
Serial.print((char)0xFF);
Serial.print((char)0x7F);
Serial.print((char)getMSB(red, green, blue));
Serial.print((char)getLSB(red, green, blue));
waitAck();
}
// draw circle
void uLCD_144::drawCircle(int x, int y, int r, byte red, byte green, byte blue) {
Serial.write(0x43);
Serial.write(x);
Serial.write(y);
Serial.write(r);
Serial.write(getMSB(red, green, blue));
Serial.write(getLSB(red, green, blue));
waitAck();
}
void uLCD_144::drawRect(int x1, int y1, int x2, int y2, byte red, byte green, byte blue) {
Serial.write(0x72);
Serial.write(x1);
Serial.write(y1);
Serial.write(x2);
Serial.write(y2);
Serial.write(getMSB(red, green, blue));
Serial.write(getLSB(red, green, blue));
waitAck();
}
uint32_t createSeed32(void){
uint8_t seedCount=0;
uint32_t seed[1]={0};
while(seedCount<32){
uint16_t adcval1 = ADC_Read();
uint16_t adcval2 = ADC_Read();
if((getLSB(adcval1) && !getLSB(adcval2))){
SetBit(seed,seedCount);
seedCount++;
}
if((!getLSB(adcval1) && getLSB(adcval2))){
ClearBit(seed,seedCount);
seedCount++;
}
}
return seed[0];
}
/**
* Count the number of set bits in a given 64-bit Integer
*
* @param bb BitBoard to count set bits in
* @return Count of all set bits in bb
*/
unsigned int countSetBits(uint64_t bb){
int count = 0;
while(bb){
bb ^= (1ull << getLSB(bb));
count += 1;
}
return count;
}
void uLCD_144::printStr(int col, int row, int font, byte red, byte green, byte blue, const char *str) {
Serial.write(0x73);
Serial.write(col);
Serial.write(row);
Serial.write(font);
Serial.write(getMSB(red, green, blue));
Serial.write(getLSB(red, green, blue));
Serial.print(str);
Serial.write((uint8_t)0);
waitAck();
}
void uLCD_144::drawLine(int x1, int y1, int x2, int y2, byte red, byte green, byte blue) {
Serial.write((byte)0x4C);
Serial.write((byte)x1);
Serial.write((byte)y1);
Serial.write((byte)x2);
Serial.write((byte)y2);
Serial.write((byte)getMSB(red, green, blue));
Serial.write((byte)getLSB(red, green, blue));
waitAck();
}
/**
* Fill an array with the bit indexes of all set bits
* in a given 64-bit Integer. Set the array index after
* the last bit index location to -1 to indicate that
* all bit indexes have been traversed
*
* @param bb BitBoard to get set bits in
* @param arr Integer Array to fill with bit indexes
*/
void getSetBits(uint64_t bb, int * arr){
int count = 0;
while(bb){
int lsb = getLSB(bb);
arr[count] = lsb;
count += 1;
bb ^= 1ull << lsb;
}
arr[count] = -1;
}
void uLCD_144::printStr(int col, int row, int font, byte red, byte green, byte blue, const __FlashStringHelper *str) {
Serial.write((byte)0x73);
Serial.write((byte)col);
Serial.write((byte)row);
Serial.write((byte)font);
Serial.write((byte)getMSB(red, green, blue));
Serial.write((byte)getLSB(red, green, blue));
Serial.print(str);
Serial.write((byte)0);
waitAck();
}
void uLCD_144::printGRStr(int x, int y, int font, byte red, byte green, byte blue, int w, int h, const char *str) {
Serial.write(0x53);
Serial.write(x);
Serial.write(y);
Serial.write(font);
Serial.write(getMSB(red, green, blue));
Serial.write(getLSB(red, green, blue));
Serial.write(w);
Serial.write(h);
Serial.print(str);
Serial.write((uint8_t)0);
waitAck();
}
void uLCD_144::printGRStr(int x, int y, int font, byte red, byte green, byte blue, int w, int h, const char *str) {
Serial.write((byte)0x53);
Serial.write((byte)x);
Serial.write((byte)y);
Serial.write((byte)font);
Serial.write((byte)getMSB(red, green, blue));
Serial.write((byte)getLSB(red, green, blue));
Serial.write((byte)w);
Serial.write((byte)h);
Serial.print(str);
Serial.write((byte)0);
waitAck();
}
// Send a QCpacket with specified ID (pID) to the specified destAddr
uint8_t QCXB::sendPacket(uint16_t destAddr, uint8_t pID, QCpacket packet) {
// Build XBpacket from QCpacket
XBpacket xbpkt;
xbpkt.type = PACKET_SEND;
xbpkt.options = 0x00;
xbpkt.destAddr = destAddr;
xbpkt.ID = pID;
xbpkt.length = 9 + packet.length;
xbpkt.message[0] = packet.command;
xbpkt.message[1] = getMSB(packet.ID);
xbpkt.message[2] = getLSB(packet.ID);
xbpkt.message[3] = getMSB(packet.length);
xbpkt.message[4] = getLSB(packet.length);
copyStr(packet.data, xbpkt.message, 0, 5, packet.length);
uint32_t checksum = 0x12345678; // TODO: calculate the actual checksum
xbpkt.message[5 + packet.length] = checksum >> 24;
xbpkt.message[6 + packet.length] = (checksum >> 16) % (1 << 8);
xbpkt.message[7 + packet.length] = (checksum >> 8) % (1 << 8);
xbpkt.message[8 + packet.length] = checksum % (1 << 8);
// Transmit XBpacket
return xb.send(xbpkt);
}
long garbleCircuit(GarbledCircuit *garbledCircuit, InputLabels inputLabels, OutputMap outputMap) {
GarblingContext garblingContext;
GarbledGate *garbledGate;
GarbledTable *garbledTable;
DKCipherContext dkCipherContext;
const __m128i *sched = ((__m128i *)(dkCipherContext.K.rd_key));
block val;
block *A, *B, *plainText,*cipherText;
block tweak;
long a, b, i, j,rnds = 10;
block blocks[4];
block keys[4];
long lsb0,lsb1;
block keyToEncrypt;
int input0, input1,output;
srand_sse( time(NULL));
createInputLabels(inputLabels, garbledCircuit->n);
garbledCircuit->id = getFreshId();
for(i=0;i<2*garbledCircuit->n;i+=2) {
garbledCircuit->wires[i/2].id = i+1;
garbledCircuit->wires[i/2].label0 = inputLabels[i];
garbledCircuit->wires[i/2].label1 = inputLabels[i+1];
}
garbledTable = garbledCircuit->garbledTable;
garblingContext.gateIndex = 0;
garblingContext.wireIndex = garbledCircuit->n + 1;
block key = randomBlock();
block rkey = randomBlock();
AES_KEY KR;
AES_set_encrypt_key(&rkey, 128, &KR);
const __m128i *sched2 = ((__m128i *)(KR.rd_key));
garblingContext.R = xorBlocks(garbledCircuit->wires[0].label0, garbledCircuit->wires[0].label1);
garbledCircuit->globalKey = key;
DKCipherInit(&key, &(garblingContext.dkCipherContext));
int tableIndex = 0;
for(i=0; i< garbledCircuit->q;i++) {
garbledGate = &(garbledCircuit->garbledGates[i]);
input0 = garbledGate->input0; input1 = garbledGate->input1;
output = garbledGate->output;
#ifdef FREE_XOR
if (garbledGate->type == XORGATE) {
garbledCircuit->wires[output].label0 = xorBlocks(garbledCircuit->wires[input0].label0, garbledCircuit->wires[input1].label0);
garbledCircuit->wires[output].label1 = xorBlocks(garbledCircuit->wires[input0].label1, garbledCircuit->wires[input1].label0);
continue;
}
#endif
tweak = makeBlock(i, (long)0);
lsb0 = getLSB(garbledCircuit->wires[input0].label0);
lsb1 = getLSB(garbledCircuit->wires[input1].label0);
char templ[20];
char templ2[20];
block val = _mm_xor_si128 (tweak, sched[0]);
for (j=1; j<rnds; j++) val = _mm_aesenc_si128 (val,sched2[j]);
*((block*)templ) = _mm_aesenclast_si128 (val, sched[j]);
val = _mm_aesenclast_si128 (val, sched[j]);
*((block *)templ2) = xorBlocks(*((block *)templ), garblingContext.R);
TRUNCATE(templ);
TRUNCATE(templ2);
block *label0 = (block *)templ;
block *label1 = (block *)templ2;
garbledCircuit->wires[garbledGate->output].label0 = *((block*)templ);
garbledCircuit->wires[garbledGate->output].label1 = *((block*)templ2);
block A0, A1, B0, B1;
A0 = DOUBLE(garbledCircuit->wires[input0].label0);
A1 = DOUBLE(garbledCircuit->wires[input0].label1);
B0 = DOUBLE(DOUBLE(garbledCircuit->wires[input1].label0));
B1 = DOUBLE(DOUBLE(garbledCircuit->wires[input1].label1));
keys[0] = xorBlocks(A0, B0);
keys[0] = xorBlocks(keys[0], tweak);
keys[1] = xorBlocks(A0,B1);
keys[1] = xorBlocks(keys[1], tweak);
keys[2] = xorBlocks(A1, B0);
keys[2] = xorBlocks(keys[2], tweak);
keys[3] = xorBlocks(A1, B1);
keys[3] = xorBlocks(keys[3], tweak);
if (garbledGate->type == ANDGATE) {
blocks[0] = xorBlocks(keys[0], *label0);
blocks[1] = xorBlocks(keys[1], *label0);
blocks[2] = xorBlocks(keys[2], *label0);
blocks[3] = xorBlocks(keys[3], *label1);
goto write;
}
if (garbledGate->type == ORGATE) {
blocks[0] = xorBlocks(keys[0], *label0);
blocks[1] = xorBlocks(keys[1], *label1);
blocks[2] = xorBlocks(keys[2], *label1);
blocks[3] = xorBlocks(keys[3], *label1);
goto write;
}
if (garbledGate->type == XORGATE) {
blocks[0] = xorBlocks(keys[0], *label0);
blocks[1] = xorBlocks(keys[1], *label1);
blocks[2] = xorBlocks(keys[2], *label1);
blocks[3] = xorBlocks(keys[3], *label0);
goto write;
}
if (garbledGate->type == NOTGATE) {
blocks[0] = xorBlocks(keys[0], *label1);
blocks[1] = xorBlocks(keys[1], *label0);
blocks[2] = xorBlocks(keys[2], *label1);
blocks[3] = xorBlocks(keys[3], *label0);
goto write;
}
write:
AES_ecb_encrypt_blks(keys, 4, &(garblingContext.dkCipherContext.K));
char toWrite[4][16];
char **dest[4];
*((block *) toWrite[0]) = xorBlocks(blocks[0], keys[0]);
*((block *) toWrite[1]) = xorBlocks(blocks[1], keys[1]);
*((block *) toWrite[2]) = xorBlocks(blocks[2], keys[2]);
*((block *) toWrite[3]) = xorBlocks(blocks[3], keys[3]);
short *cpsrc; short *cpdst;
cpsrc = (short *)toWrite[0];
cpdst = (short *)&garbledTable[tableIndex].table[2*lsb0 + lsb1];
cpdst[0]=cpsrc[0];
cpdst[1]=cpsrc[1];
cpdst[2]=cpsrc[2];
cpdst[3]=cpsrc[3];
cpdst[4]=cpsrc[4];
cpsrc = (short *)toWrite[1];
cpdst = (short *)&garbledTable[tableIndex].table[2*(lsb0) + (1-lsb1)];
cpdst[0]=cpsrc[0];
cpdst[1]=cpsrc[1];
cpdst[2]=cpsrc[2];
cpdst[3]=cpsrc[3];
cpdst[4]=cpsrc[4];
cpsrc = (short *)toWrite[2];
cpdst = (short *)&garbledTable[tableIndex].table[2*(1-lsb0) + (lsb1)];
cpdst[0]=cpsrc[0];
cpdst[1]=cpsrc[1];
cpdst[2]=cpsrc[2];
cpdst[3]=cpsrc[3];
cpdst[4]=cpsrc[4];
cpsrc = (short *)toWrite[3];
cpdst = (short *)&garbledTable[tableIndex].table[2*(1-lsb0) + (1-lsb1)];
cpdst[0]=cpsrc[0];
cpdst[1]=cpsrc[1];
cpdst[2]=cpsrc[2];
cpdst[3]=cpsrc[3];
cpdst[4]=cpsrc[4];
tableIndex++;
}
for(i=0;i<garbledCircuit->m;i++) {
outputMap[2*i] = garbledCircuit->wires[garbledCircuit->outputs[i]].label0;
outputMap[2*i+1] = garbledCircuit->wires[garbledCircuit->outputs[i]].label1;
}
return 0;
}
long garbleCircuit(GarbledCircuit *garbledCircuit, InputLabels inputLabels,
OutputMap outputMap) {
GarblingContext garblingContext;
GarbledGate *garbledGate;
GarbledTable *garbledTable;
DKCipherContext dkCipherContext;
const block *sched = ((block *) (dkCipherContext.K.rd_key));
block val;
block *A, *B, *plainText, *cipherText;
block tweak;
long i, j, rnds = 10;
block blocks[4];
block keys[4];
long lsb0, lsb1;
int input0, input1, output;
srand_sse(time(NULL));
createInputLabels(inputLabels, garbledCircuit->n);
garbledCircuit->id = getFreshId();
for (i = 0; i < 2 * garbledCircuit->n; i += 2) {
garbledCircuit->wires[i / 2].label0 = inputLabels[i];
garbledCircuit->wires[i / 2].label1 = inputLabels[i + 1];
}
garbledTable = garbledCircuit->garbledTable;
garblingContext.gateIndex = 0;
garblingContext.wireIndex = garbledCircuit->n + 1;
block key = randomBlock();
block rkey = randomBlock();
AES_KEY KR;
AES_set_encrypt_key((unsigned char *) &rkey, 128, &KR);
const __m128i *sched2 = ((__m128i *) (KR.rd_key));
garblingContext.R =
xorBlocks(garbledCircuit->wires[0].label0, garbledCircuit->wires[0].label1);
garbledCircuit->globalKey = key;
DKCipherInit(&key, &(garblingContext.dkCipherContext));
int tableIndex = 0;
for (i = 0; i < garbledCircuit->q; i++) {
garbledGate = &(garbledCircuit->garbledGates[i]);
input0 = garbledGate->input0;
input1 = garbledGate->input1;
output = garbledGate->output;
#ifdef FREE_XOR
if (garbledGate->type == XORGATE) {
garbledCircuit->wires[output].label0 =
xorBlocks(garbledCircuit->wires[input0].label0, garbledCircuit->wires[input1].label0);
garbledCircuit->wires[output].label1 =
xorBlocks(garbledCircuit->wires[input0].label1, garbledCircuit->wires[input1].label0);
continue;
}
#endif
tweak = makeBlock(i, (long)0);
lsb0 = getLSB(garbledCircuit->wires[input0].label0);
lsb1 = getLSB(garbledCircuit->wires[input1].label0);
block val = _mm_xor_si128(tweak, sched[0]);
for (j = 1; j < rnds; j++)
val = _mm_aesenc_si128(val, sched2[j]);
garbledCircuit->wires[garbledGate->output].label0 =
_mm_aesenclast_si128(val, sched[j]);
garbledCircuit->wires[garbledGate->output].label1 =
xorBlocks(garblingContext.R,
garbledCircuit->wires[garbledGate->output].label0);
block A0, A1, B0, B1;
A0 = DOUBLE(garbledCircuit->wires[input0].label0);
A1 = DOUBLE(garbledCircuit->wires[input0].label1);
B0 = DOUBLE(DOUBLE(garbledCircuit->wires[input1].label0));
B1 = DOUBLE(DOUBLE(garbledCircuit->wires[input1].label1));
keys[0] = xorBlocks(xorBlocks(A0, B0) , tweak);
keys[1] = xorBlocks(xorBlocks(A0,B1), tweak);
keys[2] = xorBlocks(xorBlocks(A1, B0), tweak);
keys[3] = xorBlocks(xorBlocks(A1, B1), tweak);
block *temp[2];
temp[0] = &garbledCircuit->wires[garbledGate->output].label0;
temp[1] = &garbledCircuit->wires[garbledGate->output].label1;
int bp = 0;
blocks[0] =
xorBlocks(keys[0], *(temp[(garbledGate->type & (1<<bp))>>bp]));
bp++;
blocks[1] =
xorBlocks(keys[1], *(temp[(garbledGate->type & (1<<bp))>>bp]));
bp++;
blocks[2] =
xorBlocks(keys[2], *(temp[(garbledGate->type & (1<<bp))>>bp]));
bp++;
blocks[3] =
xorBlocks(keys[3], *(temp[(garbledGate->type & (1<<bp))>>bp]));
write:
AES_ecb_encrypt_blks_4(keys, &(garblingContext.dkCipherContext.K));
garbledTable[tableIndex].table[2 * lsb0 + lsb1] =
xorBlocks(blocks[0], keys[0]);
garbledTable[tableIndex].table[2 * lsb0 + 1 - lsb1] =
xorBlocks(blocks[1], keys[1]);
garbledTable[tableIndex].table[2 * (1 - lsb0) + lsb1] =
xorBlocks(blocks[2], keys[2]);
garbledTable[tableIndex].table[2 * (1 - lsb0) + (1 - lsb1)] =
xorBlocks(blocks[3], keys[3]);
tableIndex++;
}
for (i = 0; i < garbledCircuit->m; i++) {
outputMap[2 * i] =
garbledCircuit->wires[garbledCircuit->outputs[i]].label0;
outputMap[2 * i + 1] =
garbledCircuit->wires[garbledCircuit->outputs[i]].label1;
}
return 0;
}
int main(int argc, char* argv[]) {
//----------------------
#ifndef DEBUG
srand(time(NULL));
srand_sse(time(NULL));
#else
srand(1);
srand_sse(1111);
#endif
if (argc < 3) {
printf("Usage: %s <scd file name> <port> \n", argv[0]);
return -1;
}
int port = atoi(argv[2]);
int connfd = server_init(port);
if (connfd == -1) {
printf("Something's wrong with the socket!\n");
return -1;
}
#define GARBLING
#ifndef GARBLING
server_close(connfd);
return 0;
#else
//----------------------------------------- Garbling
GarbledCircuit garbledCircuit;
long i, j, cid;
readCircuitFromFile(&garbledCircuit, argv[1]);
printf("garbledCircuit.I[0] = %d\n", garbledCircuit.I[0]);
int n = garbledCircuit.n;
int g = garbledCircuit.g;
int p = garbledCircuit.p;
int m = garbledCircuit.m;
int c = garbledCircuit.c;
int e = n - g;
int *garbler_inputs = (int *) malloc(sizeof(int) * (g) * c);
block *inputLabels = (block *) malloc(sizeof(block) * 2 * n * c);
block *initialDFFLable = (block *) malloc(sizeof(block) * 2 * p);
block *outputLabels = (block *) malloc(sizeof(block) * 2 * m * c);
printf("\n\ninputs:\n");
for (cid = 0; cid < c; cid++) {
for (j = 0; j < g; j++) {
garbler_inputs[cid * g + j] = rand() % 2;
printf("%d ", garbler_inputs[cid * g + j]);
}
}
printf("\n\n");
#ifndef DEBUG
block R = randomBlock();
*((short *) (&R)) |= 1;
#else
block R = makeBlock((long )(-1), (long )(-1));
#endif
uint8_t * rptr = (uint8_t*) &R;
for (int i = 0; i < 16; i++)
rptr[i] = 0xff;
// *((short *) (&R)) |= 1;
rptr[0] |= 1;
createInputLabels(inputLabels, R, n * c);
createInputLabels(initialDFFLable, R, p);
///--------------------------------------------------------------- OT Extension
//Parameters
int numOTs = c * e;
int bitlength = 128;
m_nSecParam = 128;
m_nNumOTThreads = 1;
BYTE version;
crypto *crypt = new crypto(m_nSecParam, (uint8_t*) m_vSeed);
InitOTSender(connfd, crypt);
CBitVector delta, X1, X2;
delta.Create(numOTs, bitlength, crypt);
m_fMaskFct = new XORMasking(bitlength, delta);
for (int i=0;i<numOTs;i++)
delta.SetBytes(rptr, i*16, 16);
printf("Delta: ");
for (int i = 0; i < 16; i++) {
printf("%02x", delta.GetByte(i));
}
printf("\n");
printf("R: ");
print__m128i(R);
printf("\n");
X1.Create(numOTs, bitlength);
X1.Reset();
X2.Create(numOTs, bitlength);
X2.Reset();
uint8_t* b = new BYTE[16];
BYTE* b2 = new BYTE[16];
cout << "Sender performing " << numOTs << " C_OT extensions on "
<< bitlength << " bit elements" << endl;
version = C_OT;
ObliviouslySend(X1, X2, numOTs, bitlength, version, crypt);
//putting X1 & X2 into inputLabels
printf("printing inputLabels after copy from X1 and X2:\n\n");
uint8_t* inputLabelsptr;
for (cid = 0; cid < c; cid++) {
for (j = 0; j < e; j++) {
inputLabelsptr = (uint8_t*) &inputLabels[2 * (cid * n + g + j)];
X1.GetBytes(inputLabelsptr, 16*(cid * e + j), 16);
print__m128i(inputLabels[2 * (cid * n + g + j)]);
inputLabelsptr = (uint8_t*) &inputLabels[2 * (cid * n + g + j) + 1];
X2.GetBytes(inputLabelsptr, 16*(cid * e + j), 16);
print__m128i(inputLabels[2 * (cid * n + g + j) + 1]);
}
}
//print
printf("Printing X1:\n");
for (int j = 0; j < numOTs; j++) {
for (int i = 0; i < 16; i++) {
b[i] = X1.GetByte(i + j * 16);
printf("%02x", b[i]);
}
printf("\n");
}
printf("\n\n");
printf("Printing X2:\n");
for (int j = 0; j < numOTs; j++) {
for (int i = 0; i < 16; i++) {
b[i] = X2.GetByte(i + j * 16);
printf("%02x", b[i]);
}
printf("\n");
}
printf("\n\n");
printf("Printing delta:\t");
for (int i = 0; i < 16; i++) {
b[i] = delta.GetByte(i);
printf("%02x", b[i]);
}
printf("\n");
//----------------------------------------------------end of OT Extension
for (cid = 0; cid < c; cid++) {
for (j = 0; j < g; j++) {
if (garbler_inputs[cid * g + j] == 0)
send_block(connfd, inputLabels[2 * (cid * n + j)]);
else
send_block(connfd, inputLabels[2 * (cid * n + j) + 1]);
printf("i(%ld, %ld, %d)\n", cid, j, garbler_inputs[cid * g + j]);
print__m128i(inputLabels[2 * (cid * n + j)]);
print__m128i(inputLabels[2 * (cid * n + j) + 1]);
}
//------------------------------------------------------------------------------------------ CHANGE 1
for (j = 0; j < e; j++) {
// int ev_input;
// read(connfd, &ev_input, sizeof(int));
// if (!ev_input)
// send_block(connfd, inputLabels[2 * (cid * n + g + j)]);
// else
// send_block(connfd, inputLabels[2 * (cid * n + g + j) + 1]);
printf("evaluator : i(%ld, %ld, ?)\n", cid, j);
print__m128i(inputLabels[2 * (cid * n + g + j)]);
print__m128i(inputLabels[2 * (cid * n + g + j) + 1]);
}
printf("Compare to: ");
printf("\n");
//----------------------------------------------------------------------end
}
printf("\n\n");
for (j = 0; j < p; j++) //p:#DFF
{
printf("garbledCircuit.I[j] = %d\n", garbledCircuit.I[j]);
if (garbledCircuit.I[j] == CONST_ZERO) // constant zero
{
send_block(connfd, initialDFFLable[2 * j]);
printf("dffi(%ld, %ld, %d)\n", cid, j, 0);
print__m128i(initialDFFLable[2 * j]);
print__m128i(initialDFFLable[2 * j + 1]);
} else if (garbledCircuit.I[j] == CONST_ONE) // constant zero
{
send_block(connfd, initialDFFLable[2 * j + 1]);
printf("dffi(%ld, %ld, %d)\n", cid, j, 0);
print__m128i(inputLabels[2 * j]);
print__m128i(inputLabels[2 * j + 1]);
} else if (garbledCircuit.I[j] < g) //belongs to Alice (garbler)
{
int index = garbledCircuit.I[j];
if (garbler_inputs[index] == 0)
send_block(connfd, initialDFFLable[2 * j]);
else
send_block(connfd, initialDFFLable[2 * j + 1]);
printf("dffi(%ld, %ld, %d)\n", cid, j, garbler_inputs[index]);
print__m128i(initialDFFLable[2 * j]);
print__m128i(initialDFFLable[2 * j + 1]);
}
//------------------------------------------------------------------------------------------ CHANGE 2
else //**** belongs to Bob
{
// int ev_input;
// read(connfd, &ev_input, sizeof(int));
// if (!ev_input)
// send_block(connfd, initialDFFLable[2 * j]);
// else
// send_block(connfd, initialDFFLable[2 * j + 1]);
// printf("dffi(%ld, %ld, %d)\n", cid, j, ev_input);
print__m128i(initialDFFLable[2 * j]);
print__m128i(initialDFFLable[2 * j + 1]);
printf("\n");
}
//----------------------------------------------------------------------end
}
printf("\n\n");
///--------------------------------------------------------------- OT Extension
//Parameters
numOTs = p;
delta.Create(numOTs, bitlength, crypt);
m_fMaskFct = new XORMasking(bitlength, delta);
for (int i=0;i<numOTs;i++)
delta.SetBytes(rptr, i*16, 16);
printf("Delta: ");
for (int i = 0; i < 16; i++) {
printf("%02x", delta.GetByte(i));
}
printf("\n");
printf("R: ");
print__m128i(R);
printf("\n");
X1.Create(numOTs, bitlength);
X1.Reset();
X2.Create(numOTs, bitlength);
X2.Reset();
cout << "Sender performing " << numOTs << " C_OT extensions on "
<< bitlength << " bit elements" << endl;
version = C_OT;
ObliviouslySend(X1, X2, numOTs, bitlength, version, crypt);
//putting X1 & X2 into inputLabels
printf("printing inputLabels after copy from X1 and X2:\n\n");
for (j = 0; j < p; j++) {
inputLabelsptr = (uint8_t*) &initialDFFLable[2 * j];
X1.GetBytes(inputLabelsptr, 16*(j), 16);
inputLabelsptr = (uint8_t*) &initialDFFLable[2 * j +1];
X2.GetBytes(inputLabelsptr, 16*( j), 16);
}
delete crypt;
//----------------------------------------------------end of OT Extension
garbledCircuit.globalKey = randomBlock();
send_block(connfd, garbledCircuit.globalKey); // send DKC key
printf("R: ");
print__m128i(R);
printf("\n");
garble(&garbledCircuit, inputLabels, initialDFFLable, outputLabels, &R,
connfd);
printf("***************** InputLabels\n");
for (int i=0;i<n*c*2;i++)
print__m128i(inputLabels[i]);
for (cid = 0; cid < c; cid++) {
for (i = 0; i < m; i++) {
short outputType = getLSB(outputLabels[2 * (m * cid + i) + 0]);
send_type(connfd, outputType);
}
}
server_close(connfd);
removeGarbledCircuit(&garbledCircuit);
return 0;
#endif
}
long garbleCircuit(GarbledCircuit *garbledCircuit, InputLabels inputLabels, OutputMap outputMap) {
GarblingContext garblingContext;
GarbledGate *garbledGate;
GarbledTable *garbledTable;
DKCipherContext dkCipherContext;
const __m128i *sched = ((__m128i *)(dkCipherContext.K.rd_key));
block val;
block *A, *B, *plainText,*cipherText;
block tweak;
long a, b, i, j,rnds = 10;
block blocks[4];
block keys[4];
long lsb0,lsb1;
block keyToEncrypt;
int input0, input1, output;
srand_sse( time(NULL));
createInputLabels(inputLabels, garbledCircuit->n);
garbledCircuit->id = getFreshId();
for(i=0;i<2*garbledCircuit->n;i+=2) {
garbledCircuit->wires[i/2].id = i+1;
garbledCircuit->wires[i/2].label0 = inputLabels[i];
garbledCircuit->wires[i/2].label1 = inputLabels[i+1];
}
garbledTable = garbledCircuit->garbledTable;
garblingContext.gateIndex = 0;
garblingContext.wireIndex = garbledCircuit->n + 1;
block key = randomBlock();
garblingContext.R = xorBlocks(garbledCircuit->wires[0].label0, garbledCircuit->wires[0].label1);
garbledCircuit->globalKey = key;
DKCipherInit(&key, &(garblingContext.dkCipherContext));
int tableIndex = 0;
for(i=0; i< garbledCircuit->q;i++) {
garbledGate = &(garbledCircuit->garbledGates[i]);
input0 = garbledGate->input0; input1 = garbledGate->input1;
output = garbledGate->output;
#ifdef FREE_XOR
if (garbledGate->type == XORGATE) {
garbledCircuit->wires[output].label0 = xorBlocks(garbledCircuit->wires[input0].label0, garbledCircuit->wires[input1].label0);
garbledCircuit->wires[output].label1 = xorBlocks(garbledCircuit->wires[input0].label1, garbledCircuit->wires[input1].label0);
continue;
}
#endif
tweak = makeBlock(i, (long)0);
input0 = garbledGate->input0; input1 = garbledGate->input1;
lsb0 = getLSB(garbledCircuit->wires[input0].label0);
lsb1 = getLSB(garbledCircuit->wires[input1].label0);
block A0, A1, B0, B1;
A0 = DOUBLE(garbledCircuit->wires[input0].label0);
A1 = DOUBLE(garbledCircuit->wires[input0].label1);
B0 = DOUBLE(DOUBLE(garbledCircuit->wires[input1].label0));
B1 = DOUBLE(DOUBLE(garbledCircuit->wires[input1].label1));
keys[0] = xorBlocks(A0, B0);
keys[0] = xorBlocks(keys[0], tweak);
keys[1] = xorBlocks(A0,B1);
keys[1] = xorBlocks(keys[1], tweak);
keys[2] = xorBlocks(A1, B0);
keys[2] = xorBlocks(keys[2], tweak);
keys[3] = xorBlocks(A1, B1);
keys[3] = xorBlocks(keys[3], tweak);
block mask[4]; block newToken;
mask[0] = keys[0];
mask[1] = keys[1];
mask[2] = keys[2];
mask[3] = keys[3];
AES_ecb_encrypt_blks(keys, 4, &(garblingContext.dkCipherContext.K));
mask[0] = xorBlocks(mask[0], keys[0]);
mask[1] = xorBlocks(mask[1],keys[1]);
mask[2] = xorBlocks(mask[2],keys[2]);
mask[3] = xorBlocks(mask[3],keys[3]);
if (2*lsb0 + lsb1 ==0)
newToken = mask[0];
if (2*lsb0 + 1-lsb1 ==0)
newToken = mask[1];
if (2*(1-lsb0) + lsb1 ==0)
newToken = mask[2];
if (2*(1-lsb0) + 1-lsb1 ==0)
newToken = mask[3];
block newToken2 = xorBlocks(garblingContext.R, newToken);
if (garbledGate->type == ANDGATE) {
if (lsb1 ==1 & lsb0 ==1) {
garbledCircuit->wires[garbledGate->output].label1 = newToken;
garbledCircuit->wires[garbledGate->output].label0 = newToken2;
}
else {
garbledCircuit->wires[garbledGate->output].label0 = newToken;
garbledCircuit->wires[garbledGate->output].label1 = newToken2;
}
}
if (garbledGate->type == ORGATE) {
if (!(lsb1 ==0 & lsb0 ==0)) {
garbledCircuit->wires[garbledGate->output].label1 = newToken;
garbledCircuit->wires[garbledGate->output].label0 = newToken2;
}
else {
garbledCircuit->wires[garbledGate->output].label0 = newToken;
garbledCircuit->wires[garbledGate->output].label1 = newToken2;
}
}
if (garbledGate->type == XORGATE) {
if ((lsb1 ==0 & lsb0 ==1) ||(lsb1 ==1 & lsb0 ==0) ) {
garbledCircuit->wires[garbledGate->output].label1 = newToken;
garbledCircuit->wires[garbledGate->output].label0 = newToken2;
}
else {
garbledCircuit->wires[garbledGate->output].label0 = newToken;
garbledCircuit->wires[garbledGate->output].label1 = newToken2;
}
}
if (garbledGate->type == NOTGATE) {
if (lsb0 ==0) {
garbledCircuit->wires[garbledGate->output].label1 = newToken;
garbledCircuit->wires[garbledGate->output].label0 = newToken2;
}
else {
garbledCircuit->wires[garbledGate->output].label0 = newToken;
garbledCircuit->wires[garbledGate->output].label1 = newToken2;
}
}
block *label0 = &garbledCircuit->wires[garbledGate->output].label0;
block *label1 = &garbledCircuit->wires[garbledGate->output].label1;
if (garbledGate->type == ANDGATE) {
blocks[0] = *label0;
blocks[1] = *label0;
blocks[2] = *label0;
blocks[3] = *label1;
goto write;
}
if (garbledGate->type == ORGATE) {
blocks[0] = *label0;
blocks[1] = *label1;
blocks[2] = *label1;
blocks[3] = *label1;
goto write;
}
if (garbledGate->type == XORGATE) {
blocks[0] = *label0;
blocks[1] = *label1;
blocks[2] = *label1;
blocks[3] = *label0;
goto write;
}
if (garbledGate->type == NOTGATE) {
blocks[0] = *label1;
blocks[1] = *label0;
blocks[2] = *label1;
blocks[3] = *label0;
goto write;
}
write:
if (2*lsb0 + lsb1 !=0)
garbledTable[tableIndex].table[2*lsb0 + lsb1 -1] = xorBlocks(blocks[0], mask[0]);
if (2*lsb0 + 1-lsb1 !=0)
garbledTable[tableIndex].table[2*lsb0 + 1-lsb1-1] = xorBlocks(blocks[1], mask[1]);
if (2*(1-lsb0) + lsb1 !=0)
garbledTable[tableIndex].table[2*(1-lsb0) + lsb1-1] = xorBlocks(blocks[2], mask[2]);
if (2*(1-lsb0) + (1-lsb1) !=0)
garbledTable[tableIndex].table[2*(1-lsb0) + (1-lsb1)-1] = xorBlocks(blocks[3], mask[3]);
tableIndex++;
}
for(i=0;i<garbledCircuit->m;i++) {
outputMap[2*i] = garbledCircuit->wires[garbledCircuit->outputs[i]].label0;
outputMap[2*i+1] = garbledCircuit->wires[garbledCircuit->outputs[i]].label1;
}
return 0;
}
