static int module7_init(void)
{
int port= 13394;
struct socket* serversocket;
struct socket* newsocks;
size_t recieving, lens;
char * Buffer;
Buffer = (char*)__get_free_page(GFP_KERNEL);
lens=strlen(Buffer);
serversocket= set_up_server_socket(port);
do{
newsocks= server_accept_connection(serversocket);
recieving = RecvBuffer(newsocks, Buffer, lens);
if (recieving<=0)
{
printk(KERN_INFO "Server:error when receiving message");
}
else
{
printk(KERN_INFO "Server received msg: %s",Buffer);
}
}while(1);
return 0;
}
static int module7_init(void)
{
int port= 13394;
size_t recieving;
struct netlink_kernel_cfg cfg = {
.groups = 1,
.input = netlinkmsg,
};
nl_sk = netlink_kernel_create(&init_net, 3, &cfg);
Buffer = (char*)__get_free_page(GFP_KERNEL);
serversocket= set_up_server_socket(port);
newsocks= server_accept_connection(serversocket);
recieving = RecvBuffer(newsocks, Buffer, 1024);
if (recieving<=0)
{
printk(KERN_INFO "Server:error when receiving message\n");
}
else
{
printk(KERN_INFO "Server received msg: %s \n",Buffer);
}
file1 = debugfs_create_file("mmap_example1", 0644, NULL, NULL, &my_fops);
if (file1 == NULL)
{
printk(KERN_ALERT "Error occurred\n");
}
else
{
printk("The creation of the file should has occured\n");
printk("The pointer value of the create file %p \n", &file1);
}
return 0;
}
static void module7_exit(void)
{
sock_release(serversocket);
sock_release(newsocks);
debugfs_remove(file1);
netlink_kernel_release(nl_sk);
printk(KERN_ALERT "Server exiting \n");
return;
}
static int module7_init(void)
{
int port= 13394;
unsigned int IP_addr= 168430083;
size_t sendings;
char *sendbuff;
struct socket* serversock;
struct socket* newsocket;
size_t recieve;
size_t length;
size_t lens;
char *recvbuffer;
recvbuffer = (char*)__get_free_page(GFP_KERNEL);
sendbuff= "hi i am thinh";
//file1 = debugfs_create_file("mmap_example1", 0644, NULL, NULL, &my_fops);
/*
//setup_timer(&my_timer, my_timer_callback, 0 );
if (file1 == NULL)
{
printk(KERN_ALERT "Error occurred\n");
}
else
{
printk("The creation of the file should has occured\n");
printk("The pointer value of the create file %p \n", &file1);
}
*/ lens = strlen(recvbuffer);
serversock=set_up_server_socket(port);
do{
newsocket = server_accept_connection(serversock);
recieve = RecvBuffer(newsocket, recvbuffer, lens);
if (recieve <= 0)
{
printk("Client Error when recieving msg");
break;
}
else
{
printk("ClientMSG recieved: %s \n", recvbuffer);
}
}while(1);
socketz=set_up_client_socket(IP_addr,port);
length=strlen(sendbuff);
sendings= SendBuffer(socketz, sendbuff, length);
sock_release(newsocket);
sock_release(socketz);
return 0;
}
void test_CnC_OT_Mod_Sender()
{
struct params_CnC_ECC *params_S;
struct tildeList *receivedTildeList;
struct CnC_OT_Mod_CTs **CTs;
struct CnC_OT_Mod_Check_CT **checkCTs;
struct jSetCheckTildes *checkTildes;
struct sockaddr_in destWrite, destRead;
int writeSocket, readSocket, mainWriteSock, mainReadSock;
int writePort, readPort, i, j;
unsigned char *commBuffer;
unsigned char **inputX_js, **M_0, **M_1;
int stat_SecParam = 4, comp_SecParam = 256, verified = 0;
int bufferOffset = 0, commBufferLen = 0;
const int DEBUG_TRANSFER = 1;
const int DEBUG_CHECK = 0;
inputX_js = (unsigned char **) calloc(stat_SecParam, sizeof(unsigned char*));
M_0 = (unsigned char **) calloc(stat_SecParam, sizeof(unsigned char*));
M_1 = (unsigned char **) calloc(stat_SecParam, sizeof(unsigned char*));
writePort = 7654;
readPort = writePort + 1;
gmp_randstate_t *state = seedRandGen();
set_up_server_socket(destWrite, writeSocket, mainWriteSock, writePort);
set_up_server_socket(destRead, readSocket, mainReadSock, readPort);
params_S = setup_CnC_OT_Mod_Full_Sender(writeSocket, readSocket, *state);
for(j = 0; j < stat_SecParam; j ++)
{
inputX_js[j] = generateRandBytes(16, 16);
M_0[j] = generateRandBytes(16, 16);
M_1[j] = generateRandBytes(16, 16);
if(DEBUG_TRANSFER)
{
printf("M_%d_0 = ", j);
for(i = 0; i < 16; i ++)
{
printf("%02X", M_0[j][i]);
}
printf("\nM_%d_1 = ", j);
for(i = 0; i < 16; i ++)
{
printf("%02X", M_1[j][i]);
}
printf("\n\n");
}
if(DEBUG_CHECK)
{
printf("X_%d = ", j);
for(i = 0; i < 16; i ++)
{
printf("%02X", inputX_js[j][i]);
}
printf("\n");
}
}
for(i = 0; i < 32; i ++)
{
bufferOffset = 0;
commBuffer = receiveBoth(readSocket, commBufferLen);
receivedTildeList = deserialiseTildeList(commBuffer, stat_SecParam, &bufferOffset);
free(commBuffer);
// ZKPoK
verified |= ZKPoK_Ext_DH_TupleVerifier_2U(writeSocket, readSocket, stat_SecParam,
params_S -> params -> g, params_S -> crs -> g_1,
receivedTildeList -> g_tilde, receivedTildeList -> g_tilde,
params_S -> crs -> h_0_List, params_S -> crs -> h_1_List,
receivedTildeList -> h_tildeList, params_S -> params, state);
commBufferLen = 0;
CTs = transfer_CnC_OT_Mod_Enc_i(params_S, receivedTildeList, M_0, M_1, *state);
commBuffer = serialise_Mod_CTs(CTs, stat_SecParam, &commBufferLen, 16);
sendBoth(writeSocket, commBuffer, commBufferLen);
free(commBuffer);
}
printf("Sender verify ?= %d\n", verified);
bufferOffset = 0;
commBuffer = receiveBoth(readSocket, commBufferLen);
checkTildes = deserialise_jSet_CheckTildes(commBuffer, &bufferOffset);
free(commBuffer);
checkCTs = checkCnC_OT_Mod_Enc(params_S, checkTildes, inputX_js, *state);
commBuffer = serialise_OT_Mod_Check_CTs(checkCTs, stat_SecParam, &commBufferLen, 16);
sendBoth(writeSocket, commBuffer, commBufferLen);
free(commBuffer);
ZKPoK_Ext_DH_TupleVerifierAll(writeSocket, readSocket, stat_SecParam,
params_S -> params -> g, params_S -> crs -> g_1,
checkTildes -> h_tildeList,
params_S -> params, state);
close_server_socket(writeSocket, mainWriteSock);
close_server_socket(readSocket, mainReadSock);
freeParams_CnC_ECC(params_S);
gmp_randclear(*state);
free(state);
}
void benchmark_Symm_OT_NP_Sender(char *portNumStr)
{
struct timespec timestamp_0, timestamp_1;
clock_t c_0, c_1;
struct sockaddr_in destWrite, destRead;
int writeSocket, readSocket, mainWriteSock, mainReadSock;
int writePort = atoi(portNumStr), readPort = writePort + 1;
gmp_randstate_t *state;
randctx *isaacCTX;
struct OT_NP_Receiver_Query **queries_Own;
struct eccPoint *C, *cTilde, **queries_Partner;
struct eccParams *params;
unsigned char ***OT_Inputs, **OT_Outputs, *permedInputs;
int i, j, k;
const int numIterations = 10, numX = 128, numY = 10;
initRandGen();
state = seedRandGen();
params = initBrainpool_256_Curve();
isaacCTX = (randctx*) calloc(1, sizeof(randctx));
getIsaacContext(isaacCTX);
permedInputs = (unsigned char *) calloc(numX, sizeof(unsigned char));
OT_Inputs = (unsigned char ***) calloc(2, sizeof(unsigned char **));
OT_Inputs[0] = (unsigned char **) calloc(numX * numY, sizeof(unsigned char *));
OT_Inputs[1] = (unsigned char **) calloc(numX * numY, sizeof(unsigned char *));
for(i = 0; i < numX; i ++)
{
for(j = 0; j < numY; j ++)
{
k = i * numY + j;
OT_Inputs[0][k] = generateIsaacRandBytes(isaacCTX, 16, 16);
OT_Inputs[1][k] = generateIsaacRandBytes(isaacCTX, 16, 16);
}
}
set_up_server_socket(destWrite, writeSocket, mainWriteSock, writePort);
set_up_server_socket(destRead, readSocket, mainReadSock, readPort);
c_0 = clock();
timestamp_0 = timestamp();
for(i = 0; i < numIterations; i ++)
{
C = setup_OT_NP_Sender(params, *state);
cTilde = exchangeC_ForNaorPinkas(writeSocket, readSocket, C);
printf(">>> %d\n", i);
// full_CnC_OT_Mod_Receiver_ECC_Alt(writeSocket, readSocket, &OT_Outputs, numX, state, startOfInputChain, permedInputs, numY, 1024);
queries_Own = NaorPinkas_OT_Produce_Queries(numX, permedInputs, state, params, cTilde);
queries_Partner = NaorPinkas_OT_Exchange_Queries(writeSocket, readSocket, numX,
numX, queries_Own);
NaorPinkas_OT_Sender_Transfer(writeSocket, readSocket, numX, OT_Inputs, state, numY, queries_Partner, params, C);
OT_Outputs = NaorPinkas_OT_Receiver_Transfer(writeSocket, readSocket, numX, permedInputs, state, numY, queries_Own, params, cTilde);
}
c_1 = clock();
timestamp_1 = timestamp();
printf("\nOT_NP %d times, %d by %d\n", numIterations, numX, numY);
printf("CPU time : %f\n", (float) (c_1 - c_0)/CLOCKS_PER_SEC);
printf("Wall time : %lf\n", seconds_timespecDiff(×tamp_0, ×tamp_1));
close_server_socket(writeSocket, mainWriteSock);
close_server_socket(readSocket, mainReadSock);
}
void benchmark_OT_L_CnC_Mod_Sender(char *portNumStr)
{
struct timespec timestamp_0, timestamp_1;
clock_t c_0, c_1;
struct sockaddr_in destWrite, destRead;
int writeSocket, readSocket, mainWriteSock, mainReadSock;
int writePort = atoi(portNumStr), readPort = writePort + 1;
gmp_randstate_t *state;
randctx *isaacCTX;
unsigned char ***OT_Inputs, **Xj_checkValues;
const int numIterations = 10, numX = 128, numY = 10;
int i, j, k;
initRandGen();
state = seedRandGen();
isaacCTX = (randctx*) calloc(1, sizeof(randctx));
getIsaacContext(isaacCTX);
OT_Inputs = (unsigned char ***) calloc(2, sizeof(unsigned char **));
OT_Inputs[0] = (unsigned char **) calloc(numX * numY, sizeof(unsigned char *));
OT_Inputs[1] = (unsigned char **) calloc(numX * numY, sizeof(unsigned char *));
for(i = 0; i < numX; i ++)
{
for(j = 0; j < numY; j ++)
{
k = i * numY + j;
OT_Inputs[0][k] = generateIsaacRandBytes(isaacCTX, 16, 16);
OT_Inputs[1][k] = generateIsaacRandBytes(isaacCTX, 16, 16);
}
}
Xj_checkValues = (unsigned char **) calloc(numY, sizeof(unsigned char *));
for(j = 0; j < numY; j ++)
{
Xj_checkValues[j] = generateIsaacRandBytes(isaacCTX, 16, 16);
}
set_up_server_socket(destWrite, writeSocket, mainWriteSock, writePort);
set_up_server_socket(destRead, readSocket, mainReadSock, readPort);
c_0 = clock();
timestamp_0 = timestamp();
for(i = 0; i < numIterations; i ++)
{
printf(">>> %d\n", i);
full_CnC_OT_Mod_Sender_ECC(writeSocket, readSocket, numX, OT_Inputs, Xj_checkValues, state, numY, 1024);
}
c_1 = clock();
timestamp_1 = timestamp();
printf("\nLP_CnC OT %d times, %d by %d\n", numIterations, numX, numY);
printf("CPU time : %f\n", (float) (c_1 - c_0)/CLOCKS_PER_SEC);
printf("Wall time : %lf\n", seconds_timespecDiff(×tamp_0, ×tamp_1));
close_server_socket(writeSocket, mainWriteSock);
close_server_socket(readSocket, mainReadSock);
}
void runBuilder_L_2013_CnC_OT(struct RawCircuit *rawInputCircuit, struct idAndValue *startOfInputChain, char *portNumStr, randctx *ctx)
{
struct sockaddr_in destWrite, destRead;
int writeSocket, readSocket, mainWriteSock, mainReadSock;
int writePort = atoi(portNumStr), readPort = writePort + 1;
struct Circuit **circuitsArray;
struct RawCircuit *rawCheckCircuit = createRawCheckCircuit(rawInputCircuit -> numInputs_P1);
int i, arrayLen, commBufferLen = 0, J_setSize = 0;
const int lengthDelta = 40;
struct timespec ext_t_0, ext_t_1;
struct timespec int_t_0, int_t_1;
clock_t ext_c_0, ext_c_1;
clock_t int_c_0, int_c_1;
gmp_randstate_t *state;
struct public_builderPRS_Keys *public_inputs;
struct secret_builderPRS_Keys *secret_inputs, *checkSecretInputs;
struct eccParams *params;
struct secCompBuilderOutput *SC_ReturnStruct;
struct eccPoint **builderInputs, ***consistentInputs;
unsigned char *commBuffer, *J_set, ***bLists, ***hashedB_Lists, *delta;
unsigned char **Xj_checkValues, ***OT_Inputs, *inputArray;
ub4 **circuitSeeds = (ub4 **) calloc(stat_SecParam, sizeof(ub4*));
randctx **circuitCTXs = (randctx **) calloc(stat_SecParam, sizeof(randctx*));
initRandGen();
state = seedRandGen();
Xj_checkValues = (unsigned char **) calloc(stat_SecParam, sizeof(unsigned char *));
// Some initialisation of randomness and input arrays.
inputArray = convertChainIntoArray(startOfInputChain, rawInputCircuit -> numInputs_P1);
for(i = 0; i < stat_SecParam; i ++)
{
circuitCTXs[i] = (randctx*) calloc(1, sizeof(randctx));
circuitSeeds[i] = getIsaacContext(circuitCTXs[i]);
}
set_up_server_socket(destWrite, writeSocket, mainWriteSock, writePort);
set_up_server_socket(destRead, readSocket, mainReadSock, readPort);
ext_t_0 = timestamp();
ext_c_0 = clock();
printf("Executor has connected to us.\n");
int_t_0 = timestamp();
int_c_0 = clock();
// Input/Output generation
params = initBrainpool_256_Curve();
secret_inputs = generateSecrets(rawInputCircuit -> numInputs_P1, stat_SecParam, params, *state);
public_inputs = computePublicInputs(secret_inputs, params);
delta = generateRandBytes(16, 16);
bLists = generateConsistentOutputs(delta, rawInputCircuit -> numOutputs);
hashedB_Lists = generateConsistentOutputsHashTables(bLists, rawInputCircuit -> numOutputs);
// Check values for use in the modified CnC OT.
for(i = 0; i < stat_SecParam; i ++)
{
Xj_checkValues[i] = generateRandBytes(16, 16);
}
int_c_1 = clock();
int_t_1 = timestamp();
printTiming(&int_t_0, &int_t_1, int_c_0, int_c_1, "Circuit Input Prep");
printAndZeroBothCounters();
int_t_0 = timestamp();
int_c_0 = clock();
circuitsArray = buildAllCircuitsConsistentOutput(rawInputCircuit, startOfInputChain, *state, stat_SecParam, bLists[0], bLists[1],
params, secret_inputs, public_inputs, circuitCTXs, circuitSeeds);
int_c_1 = clock();
int_t_1 = timestamp();
printTiming(&int_t_0, &int_t_1, int_c_0, int_c_1, "Circuit Building");
printAndZeroBothCounters();
int_t_0 = timestamp();
int_c_0 = clock();
OT_Inputs = getAllInputKeys(circuitsArray, stat_SecParam);
full_CnC_OT_Mod_Sender_ECC(writeSocket, readSocket, circuitsArray[0] -> numInputsExecutor, OT_Inputs, Xj_checkValues, state, stat_SecParam, 1024);
int_c_1 = clock();
int_t_1 = timestamp();
printTiming(&int_t_0, &int_t_1, int_c_0, int_c_1, "OT - Sender");
printAndZeroBothCounters();
int_t_0 = timestamp();
int_c_0 = clock();
// Send all the public_builder_PRS_keys, thus commiting the Builder to the soon to follow circuits.
sendPublicCommitments(writeSocket, readSocket, public_inputs, params);
for(i = 0; i < stat_SecParam; i++)
{
sendCircuit(writeSocket, readSocket, circuitsArray[i]);
}
commBufferLen = 0;
commBuffer = serialise3D_UChar_Array(hashedB_Lists, rawInputCircuit -> numOutputs, 16, &commBufferLen);
sendBoth(writeSocket, commBuffer, commBufferLen);
free(commBuffer);
int_c_1 = clock();
int_t_1 = timestamp();
printTiming(&int_t_0, &int_t_1, int_c_0, int_c_1, "Sending Circuit and Commitments.");
fflush(stdout);
printAndZeroBothCounters();
int_t_0 = timestamp();
int_c_0 = clock();
// At this point receive from the Executor the proof of the J-set. Then provide the relevant r_j's.
J_set = builder_decommitToJ_Set(writeSocket, readSocket, circuitsArray, secret_inputs, stat_SecParam, &J_setSize, circuitSeeds);
builderInputs = computeBuilderInputs(public_inputs, secret_inputs,
J_set, J_setSize, startOfInputChain,
params, &arrayLen);
commBuffer = serialise_ECC_Point_Array(builderInputs, arrayLen, &commBufferLen);
sendBoth(writeSocket, commBuffer, commBufferLen);
free(commBuffer);
// Serialise and send the permuted input bits for the Builder's inputs on the evaluation circuits.
commBuffer = serialiseBuilderInputBits(circuitsArray, inputArray, rawInputCircuit -> numInputs_P1,
J_set, stat_SecParam, &commBufferLen);
sendBoth(writeSocket, commBuffer, commBufferLen);
free(commBuffer);
checkSecretInputs = generateSecretsCheckComp(rawInputCircuit -> numInputs_P1, 3 * stat_SecParam,
secret_inputs, params, *state);
int_c_1 = clock();
int_t_1 = timestamp();
printTiming(&int_t_0, &int_t_1, int_c_0, int_c_1, "Decommit to J_Sets secrets");
printAndZeroBothCounters();
int_t_0 = timestamp();
int_c_0 = clock();
// Run the sub-computation with 3 * S many circuits.
SC_ReturnStruct = SC_DetectCheatingBuilder(writeSocket, readSocket, rawCheckCircuit,
startOfInputChain, delta, lengthDelta,
checkSecretInputs, (3 * stat_SecParam), state);
int_c_1 = clock();
int_t_1 = timestamp();
printTiming(&int_t_0, &int_t_1, int_c_0, int_c_1, "Full cheating detection sub-computation");
printAndZeroBothCounters();
int_t_0 = timestamp();
int_c_0 = clock();
commBufferLen = 0;
commBuffer = serialise3D_UChar_Array(bLists, rawInputCircuit -> numOutputs, 16, &commBufferLen);
sendBoth(writeSocket, commBuffer, commBufferLen);
free(commBuffer);
int_c_1 = clock();
int_t_1 = timestamp();
printTiming(&int_t_0, &int_t_1, int_c_0, int_c_1, "Sending bLists");
printAndZeroBothCounters();
int_t_0 = timestamp();
int_c_0 = clock();
proveConsistencyEvaluationKeys_Builder_L_2013(writeSocket, readSocket, J_set, J_setSize,
startOfInputChain, builderInputs,
public_inputs, secret_inputs, params, SC_ReturnStruct, state);
int_c_1 = clock();
int_t_1 = timestamp();
printTiming(&int_t_0, &int_t_1, int_c_0, int_c_1, "Proving consistency");
printAndZeroBothCounters();
ext_c_1 = clock();
ext_t_1 = timestamp();
freeRawCircuit(rawInputCircuit);
printTiming(&ext_t_0, &ext_t_1, ext_c_0, ext_c_1, "Total time without connection setup");
printBothTotalCounters();
free_idAndValueChain(startOfInputChain);
/*
Freeing here is pointless because we're so close to finish when the OS will do it for us.
for(i = 0; i < stat_SecParam; i ++)
{
freeCircuitStruct(circuitsArray[i], 0);
}
*/
close_server_socket(writeSocket, mainWriteSock);
close_server_socket(readSocket, mainReadSock);
}
