void CIMainWindow::checkUpdateOnce()
{
comm.run();
QString ret = comm.ret;
bool isUpdated = ret.contains("Updated to revision");
if (isUpdated)
{
if (mProcBuild->state() == QProcess::ProcessState::NotRunning)
{
startBuilding();
QString msg = QTime::currentTime().toString() + ": " + "Start Building...";
ui->textBrowser->append(msg);
saveHtml(msg);
}
else
{
}
}
else
{
QString msg = QTime::currentTime().toString() + ": " + "No change since last check";
ui->textBrowser->append(msg);
saveHtml(msg);
}
}
void CIMainWindow::buildAnotherSolutionOrDone()
{
if (mBuildingCount < (unsigned)mCompilerParamList.size())
{
startBuilding();
}
else
{
ui->textBrowser->append("<font color=green><strong>" + QString("Successfully Built!") + "</strong></font>");
}
}
static void
buildAESCircuit(GarbledCircuit *gc, block *inputLabels)
{
GarblingContext ctxt;
int q = 50000; //Just an upper bound
int r = 50000;
int *addKeyInputs = calloc(2 * m, sizeof(int));
int *addKeyOutputs = calloc(m, sizeof(int));
int *subBytesOutputs = calloc(m, sizeof(int));
int *shiftRowsOutputs = calloc(m, sizeof(int));
int *mixColumnOutputs = calloc(m, sizeof(int));
block *outputMap = allocate_blocks(2 * m);
createEmptyGarbledCircuit(gc, n, m, q, r, inputLabels);
startBuilding(gc, &ctxt);
countToN(addKeyInputs, 256);
for (int round = 0; round < roundLimit; round++) {
AddRoundKey(gc, &ctxt, addKeyInputs, addKeyOutputs);
for (int i = 0; i < 16; i++) {
SubBytes(gc, &ctxt, addKeyOutputs + 8 * i, subBytesOutputs + 8 * i);
}
ShiftRows(gc, &ctxt, subBytesOutputs, shiftRowsOutputs);
for (int i = 0; i < 4; i++) {
if (round != roundLimit - 1)
MixColumns(gc, &ctxt, shiftRowsOutputs + i * 32,
mixColumnOutputs + 32 * i);
}
for (int i = 0; i < 128; i++) {
addKeyInputs[i] = mixColumnOutputs[i];
addKeyInputs[i + 128] = (round + 2) * 128 + i;
}
}
finishBuilding(gc, &ctxt, outputMap, mixColumnOutputs);
/* writeCircuitToFile(gc, AES_CIRCUIT_FILE_NAME); */
free(addKeyInputs);
free(addKeyOutputs);
free(subBytesOutputs);
free(shiftRowsOutputs);
free(mixColumnOutputs);
free(outputMap);
}
int main(int argc, char **argv) {
srand(time(NULL));
GarbledCircuit garbledCircuit;
GarblingContext garblingContext;
if (argc != 2) {
printf("Usage: <prog_name> number_of_gates (in thousands)");
}
//Set up circuit parameters
int n = atoi(argv[1]) * 1024;
int m = 1;
int q = n;
int r = 5 * n;
//Set up input and output tokens/labels.
block *labels = (block*) malloc(sizeof(block) * 2 * n);
block *exlabels = (block*) malloc(sizeof(block) * n);
block *outputbs2 = (block*) malloc(sizeof(block) * m);
block *outputbs = (block*) malloc(sizeof(block) * m);
int *inp = (int *) malloc(sizeof(int) * n);
countToN(inp, n);
int outputs[1];
OutputMap outputMap = outputbs;
InputLabels inputLabels = labels;
//Actually build a circuit. Alternatively, this circuit could be read
//from a file.
createInputLabels(labels, n);
createEmptyGarbledCircuit(&garbledCircuit, n, m, q, r, inputLabels);
startBuilding(&garbledCircuit, &garblingContext);
MIXEDCircuit(&garbledCircuit, &garblingContext, n, inp, outputs);
finishBuilding(&garbledCircuit, &garblingContext, outputMap, outputs);
//Garble the built circuit.
garbleCircuit(&garbledCircuit, inputLabels, outputMap);
//Evaluate the circuit with random values and check the computed
//values match the outputs of the desired function.
checkCircuit(&garbledCircuit, inputLabels, outputMap, &(checkfn));
return 0;
}
void CIMainWindow::on_actionForce_Build_triggered()
{
ui->actionForce_Build->setEnabled(false);
startBuilding();
}
int main() {
char* refId = "rs1048659";
char* name = "HG00372";
// CI part
int i,j;
read_names();
read_ids();
int size_names = size_of_names();
int size_ids = size_of_ids();
int refId_id = find_ids_id(refId);
int name_id = find_name_id(name);
read_encs();
char encC = get_char_in_enc((size_names*refId_id)+name_id);
read_skeys();
char skeyC = get_char_in_skeys((size_names*refId_id)+name_id);
// SPU -> GC building part
GarbledCircuit garbledCircuit;
GarblingContext garblingContext;
int inputsNb = 32;
int wiresNb = 50000;
int gatesNb = 50000;
int outputsNb = 32;
//Create a circuit.
block labels[2 * inputsNb];
createInputLabels(labels, inputsNb);
InputLabels inputLabels = labels;
createEmptyGarbledCircuit(&garbledCircuit, inputsNb, outputsNb, gatesNb,
wiresNb, inputLabels);
startBuilding(&garbledCircuit, &garblingContext);
// Transform generator's input into fixed wire
int zero = fixedZeroWire(&garbledCircuit,&garblingContext);
int one = fixedOneWire(&garbledCircuit,&garblingContext);
int onewire = getNextWire(&garblingContext);
NOTGate(&garbledCircuit,&garblingContext,zero,onewire);
int zerowire = getNextWire(&garblingContext);
NOTGate(&garbledCircuit,&garblingContext,one,zerowire);
int outputs[outputsNb];
int *inp = (int *) malloc(sizeof(int) * inputsNb*2);
countToN(inp, inputsNb);
//countToN(outputs, inputsNb);
int bits[inputsNb];
int_into_ints(encC,bits);
for (i = 0; i < inputsNb; i++) {
if (bits[i]) {
inp[inputsNb+i] = onewire;
} else {
inp[inputsNb+i] = zerowire;
}
}
int tempOutput[2*outputsNb];
XORCircuit(&garbledCircuit, &garblingContext, inputsNb*2, inp, outputs);
block *outputbs = (block*) malloc(sizeof(block) * outputsNb);
OutputMap outputMap = outputbs;
finishBuilding(&garbledCircuit, &garblingContext, outputMap, outputs);
garbleCircuit(&garbledCircuit, inputLabels, outputMap);
// MU -> Evaluation part
block extractedLabels[inputsNb];
int extractedInputs[inputsNb];
int_into_ints(skeyC,extractedInputs);
extractLabels(extractedLabels, inputLabels, extractedInputs, inputsNb);
block computedOutputMap[outputsNb];
evaluate(&garbledCircuit, extractedLabels, computedOutputMap);
int outputVals[outputsNb];
mapOutputs(outputMap, computedOutputMap, outputVals, outputsNb);
//TODO
int res = ints_into_int(outputVals);
printf("RESULT IS : %d\n",res);
return 0;
}
void CheeseStrategies::StandardPlay::init() {
BaseManagerSet::iterator first = g_baseManagers.begin();
m_base = *first;
startBuilding();
}
