int main(int argc, char *argv[])
{
argmap_t argmap;
argmap["c"] = "2";
argmap["k"] = "80";
argmap["L"] = "20";
argmap["m"] = "0";
argmap["n"] = "0";
// get parameters from the command line
if (!parseArgs(argc, argv, argmap)) usage(argv[0]);
long c = atoi(argmap["c"]);
long k = atoi(argmap["k"]);
long L = atoi(argmap["L"]);
long chosen_m = atoi(argmap["m"]);
long n = atoi(argmap["n"]);
long w = 64; // Hamming weight of secret key
// long L = z*R; // number of levels
long m = FindM(k, L, c, 2, 1, 0, chosen_m, true);
setTimersOn();
TestIt(c, k, w, L, m, n);
cerr << endl;
printAllTimers();
cerr << endl;
}
int main(int argc, char *argv[])
{
argmap_t argmap;
argmap["R"] = "1";
argmap["p"] = "2";
argmap["r"] = "1";
argmap["d"] = "1";
argmap["c"] = "2";
argmap["k"] = "80";
argmap["L"] = "0";
argmap["s"] = "0";
argmap["m"] = "0";
argmap["repeat"] = "1";
// get parameters from the command line
if (!parseArgs(argc, argv, argmap)) usage(argv[0]);
long R = atoi(argmap["R"]);
long p = atoi(argmap["p"]);
long r = atoi(argmap["r"]);
long d = atoi(argmap["d"]);
long c = atoi(argmap["c"]);
long k = atoi(argmap["k"]);
// long z = atoi(argmap["z"]);
long L = atoi(argmap["L"]);
if (L==0) { // determine L based on R,r
L = 3*R+3;
if (p>2 || r>1) { // add some more primes for each round
long addPerRound = 2*ceil(log((double)p)*r*3)/(log(2.0)*NTL_SP_NBITS) +1;
L += R * addPerRound;
}
}
long s = atoi(argmap["s"]);
long chosen_m = atoi(argmap["m"]);
long repeat = atoi(argmap["repeat"]);
long w = 64; // Hamming weight of secret key
// long L = z*R; // number of levels
long m = FindM(k, L, c, p, d, s, chosen_m, true);
setTimersOn();
for (long repeat_cnt = 0; repeat_cnt < repeat; repeat_cnt++) {
TestIt(R, p, r, d, c, k, w, L, m);
}
}
void dump_FHE_setting_to_file(const std::string& file, long k,
long m, long p,
long r, long L)
{
FHEcontext context(m, p, r);
FindM(k, L, 2, p, 0, 1, m, true);
buildModChain(context, L);
FHESecKey sk(context);
sk.GenSecKey(64);
addSome1DMatrices(sk);
std::fstream out;
out.open(file, std::ios::out);
if (!out.is_open()) {
std::cerr << "Can not open file: " << file << std::endl;
return;
}
out << context;
out << sk;
out.close();
}
int main(){
cout << "This experiment check for different values of parameters, how much time it takes to encrypt and decrypt a \"full\" matrix (nslots*nslots), and multply 2 encrypted matrices\nAlso check for what size of matrices, the multiplication in the server on the encrypted data is faster than for the user than do all the work on his machine. Using this formula: N > n(P)*(2*Enc(P)+Dec(P)) when:\nP is the parameters\nn(P) is the nslots value for these values\nEnc(P) and Dec(P) is the time it takes to encrypt and decrypt the matrics in size nslots*nslots\nNOTE: this formula don't take into account the time it takes to send and recieve the data to and from the server, and the time it took to the server to do the actual multiplication\n" << endl;
/*
long m=0, r=1; // Native plaintext space
int p = 65539; // Computations will be 'modulo p'
long L=16; // Levels
long c=3; // Columns in key switching matrix
long w=64; // Hamming weight of secret key
long d=0;
long s = 0; //minimum number of slots [ default=0 ]
long security = 128;*/
long m, r, p, L, c, w, s, d, security, enc1, enc2, dec, encMul, ptMul, recommended;
char tempChar;
bool toEncMult = false, toPrint = false, debugMul = false, toSave = false;
//Scan parameters
cout << "Enter HElib's keys paramter. Enter zero for the recommended values" << endl;
while(true){
cout << "Enter the field of the computations (a prime number): ";
cin >> p;
if(isPrime(p))
break;
cout << "Error! p must be a prime number! " << endl;
}
while(true){
recommended = 1;
cout << "Enter r (recommended " << recommended <<"): ";
cin >> r;
if(r == 0)
r = recommended;
if(r > 0)
break;
cout << "Error! r must be a positive number!" << endl;
}
while(true){
recommended = 16;
cout << "Enter L (recommended " << recommended <<"): ";
cin >> L;
if(L == 0)
L = recommended;
if(L > 1)
break;
cout << "Error! L must be a positive number!" << endl;
}
while(true){
recommended = 3;
cout << "Enter c (recommended " << recommended <<"): ";
cin >> c;
if(c == 0)
c = recommended;
if(c > 1)
break;
cout << "Error! c must be a positive number!" << endl;
}
while(true){
recommended = 64;
cout << "Enter w (recommended " << recommended <<"): ";
cin >> w;
if(w == 0)
w = recommended;
if(w > 1)
break;
cout << "Error! w must be a positive number!" << endl;
}
while(true){
recommended = 0;
cout << "Enter d (recommended " << recommended <<"): ";
cin >> d;
if(d >= 0)
break;
cout << "Error! d must be a positive or zero!" << endl;
}
while(true){
recommended = 0;
cout << "Enter s (recommended " << recommended <<"): ";
cin >> s;
if(s >= 0)
break;
cout << "Error! s must be a positive or zero!" << endl;
}
while(true){
recommended = 128;
cout << "Enter security (recommended " << recommended << "): ";
cin >> security;
if(security == 0)
security = recommended;
if(security >= 1)
break;
cout << "Error! security must be a positive number " << endl;
}
ZZX G;
m = FindM(security,L,c,p, d, s, 0);
FHEcontext context(m, p, r);
// initialize context
buildModChain(context, L, c);
// modify the context, adding primes to the modulus chain
FHESecKey secretKey(context);
// construct a secret key structure
const FHEPubKey& publicKey = secretKey;
// an "upcast": FHESecKey is a subclass of FHEPubKey
//if(0 == d)
G = context.alMod.getFactorsOverZZ()[0];
secretKey.GenSecKey(w);
// actually generate a secret key with Hamming weight w
addSome1DMatrices(secretKey);
EncryptedArray ea(context, G);
// constuct an Encrypted array object ea that is
// associated with the given context and the polynomial G
long nslots = ea.size(), field = power(p,r);
cout << "nslots: " << nslots << endl ;
cout << "Computations will be modulo " << field << endl;
cout << "m: " << m << endl;
unsigned int sz1, sz2, sz3;
while(true){
cout << "Enter number of rows in the first matrix: ";
cin >> sz1;
if(sz1 > 1 && sz1 <= nslots)
break;
cout << "Error! the value must be between 1 to " << nslots << "!" << endl;
}
while(true){
cout << "Enter number of rows in the first matrix: ";
cin >> sz2;
if(sz1 > 2 && sz2 <= nslots)
break;
cout << "Error! the value must be between 1 to " << nslots << "!" << endl;
}
while(true){
cout << "Enter number of rows in the first matrix: ";
cin >> sz3;
if(sz1 > 3 && sz3 <= nslots)
break;
cout << "Error! the value must be between 1 to " << nslots << "!" << endl;
}
PTMatrix PTmat1(MatSize(sz1, sz2),field), PTmat2(MatSize(sz2, sz3), field); //random matrix in size origSize1
while(true){
cout << "To multiply the encrypted matrices? Not affecting the formula, just for statistic" << endl;
cout << "Y for yes, N for no: ";
cin >> tempChar;
if(tempChar == 'Y' || tempChar == 'y'){
toEncMult = true;
break;
}
if(tempChar == 'N' || tempChar == 'n'){
toEncMult = false;
break;
}
cout << "Error! invalid input!" << endl;
}
while(toEncMult){
cout << "Debug the multiplication steps?\nY for yesm N for no :";
cin >> tempChar;
if(tempChar == 'Y' || tempChar == 'y'){
debugMul = true;
break;
}
if(tempChar == 'N' || tempChar == 'n'){
debugMul = false;
break;
}
cout << "Error! invalid input!" << endl;
}
while(true){
cout << "Print the matrices?" << endl;
cout << "Y for yes, N for no: ";
cin >> tempChar;
if(tempChar == 'Y' || tempChar == 'y'){
toPrint = true;
break;
}
if(tempChar == 'N' || tempChar == 'n'){
toPrint = false;
break;
}
cout << "Error! invalid input!" << endl;
}
while(true){
cout << "Save the matrices?" << endl;
cout << "Y for yes, N for no: ";
cin >> tempChar;
if(tempChar == 'Y' || tempChar == 'y'){
toSave = true;
break;
}
if(tempChar == 'N' || tempChar == 'n'){
toSave = false;
break;
}
cout << "Error! invalid input!" << endl;
}
if(toPrint){
PTmat1.print();
PTmat2.print();
}
if(toSave){
ofstream out_mat1("mat1.txt"), out_mat2("mat2.txt");
PTmat1.save(out_mat1);
PTmat2.save(out_mat2);
out_mat1.close(); out_mat2.close();
}
//encryptions
cout << "Encrypting the first matrices..." << endl;
resetTimers();
EncryptedMatrix encMat1 = PTmat1.encrypt(ea, publicKey);
enc1 = stopTimers("to encrypt the first matrix");
cout << "Encrypting the second matrices..." << endl;
resetTimers();
EncryptedMatrix encMat2 = PTmat2.encrypt(ea, publicKey);
enc2 = stopTimers("to encrypt the second matrix");
//multiplication
if(toEncMult){
cout << "Multiplying the matrices..." << endl;
resetTimers();
if(debugMul)
encMat1 = encMat1.debugMul(encMat2); //same as encMat1 *= encMat2 but print progress update
else
encMat1 *= encMat2;
encMul = stopTimers("to multiply the matrices");
}
cout << "Decrypting the result..." << endl;
resetTimers();
PTMatrix res = encMat1.decrypt(ea, secretKey);
dec = stopTimers("to decrypt the result");
if(toPrint)
res.print("Solution: ");
resetTimers();
PTMatrix PTres = PTmat1.mulWithMod(PTmat2,field); //like (PTmat1*PTmat2)%p but do modulu after each multiplication to avoid overflow
ptMul = stopTimers("to multiply the regular matrices");
if(toSave){
ofstream out_res("mat_res.txt"), out_ptRes("mat_pt_res.txt");
res.save(out_res);
PTres.save(out_ptRes);
out_res.close(); out_ptRes.close();
}
//PTres.print("pt result: ");
cout << "\n\n----------------------------------------Summary------------------------------ " << endl;
cout << "p: " << p << ", r: " << r << ", L: " << L << ", c: " << c << ", w: " << w << ", d: " << d << ", s: " << s << ", security: " << security << endl;
cout << "nslots: " << nslots << "\nm: " << m << endl;
cout << "It took " << enc1 << " clock ticks to encrypt the first matrix" << endl;
cout << "It took " << enc2 << " clock ticks to encrypt the second matrix" << endl;
cout << "It took " << dec << " clock ticks to decrypt the result" << endl;
cout << "It took " << ptMul << " clock ticks to multiply the regular matrices" << endl;
if(toEncMult){
cout << "It took " << encMul << " clock ticks to multiply the encrypted matrices" << endl;
cout << "is correct? " << (res==PTres) << endl;
}
long N = nslots*(enc1+enc2+dec)/ptMul;
cout << "N should be greater than " << N << endl;
return 0;
}
int main(int argc, char *argv[]) {
/*************************** INIT ***************************/
/* most of the init code is copied directly from HElibs general test (https://github.com/shaih/HElib/blob/master/src%2FTest_General.cpp) */
cerr << "*************************** INIT ***************************" << "\n";
argmap_t argmap;
argmap["R"] = "1";
argmap["p"] = "113";
argmap["r"] = "1";
argmap["d"] = "1";
argmap["c"] = "2";
argmap["k"] = "80";
argmap["L"] = "0";
argmap["s"] = "0";
argmap["m"] = "0";
long R = atoi(argmap["R"]);
long p = atoi(argmap["p"]);
long r = atoi(argmap["r"]);
long d = atoi(argmap["d"]);
long c = atoi(argmap["c"]);
long k = atoi(argmap["k"]);
// long z = atoi(argmap["z"]);
long L = atoi(argmap["L"]);
if (L==0) { // determine L based on R,r
L = 3*R+3;
if (p>2 || r>1) { // add some more primes for each round
long addPerRound = 2*ceil(log((double)p)*r*3)/(log(2.0)*NTL_SP_NBITS) +1;
L += R * addPerRound;
}
}
long s = atoi(argmap["s"]);
long chosen_m = atoi(argmap["m"]);
long w = 64; // Hamming weight of secret key
// long L = z*R; // number of levels
long m = FindM(k, L, c, p, d, s, chosen_m, true);
cerr << "\n\nR=" << R
<< ", p=" << p
<< ", r=" << r
<< ", d=" << d
<< ", c=" << c
<< ", k=" << k
<< ", w=" << w
<< ", L=" << L
<< ", m=" << m
<< endl;
FHEcontext context(m, p, r);
buildModChain(context, L, c);
context.zMStar.printout();
cerr << endl;
FHESecKey secretKey(context);
const FHEPubKey& publicKey = secretKey;
secretKey.GenSecKey(w); // A Hamming-weight-w secret key
ZZX G;
if (d == 0)
G = context.alMod.getFactorsOverZZ()[0];
else
G = makeIrredPoly(p, d);
cerr << "G = " << G << "\n";
cerr << "generating key-switching matrices... ";
addSome1DMatrices(secretKey); // compute key-switching matrices that we need
cerr << "done\n";
cerr << "computing masks and tables for rotation...";
EncryptedArray ea(context, G);
cerr << "done\n";
long nslots = ea.size();
cerr << "slots = " << nslots << "\n";
// set this to the maximum amount of delegates you want to use
int delegateLimit = 10;
if(delegateLimit > nslots) {
cerr << "delegateLimit must be <= nslots\n";
exit(1);
}
cerr << "delegateLimit = " << delegateLimit << "\n";
/*************************** INIT ***************************/
cerr << "*************************** INIT ***************************" << "\n\n";
cerr << "Reading delegate votes";
vector<vector <long> > delegateVotes = readDelegateVotes("delegate_votes.txt", nslots, delegateLimit);
cerr << "done\n";
cerr << "Encoding delegate votes...\n";
vector<PlaintextArray> delegateVotesEncoded = encodeVotes(delegateVotes, ea);
cerr << "Encrypting delegate votes...\n";
vector<Ctxt> delegateVotesEncrypted = encryptVotes(delegateVotesEncoded, ea, publicKey);
cerr << "Reading direct votes";
vector<vector <long> > votes = readVotes("direct_votes.txt", nslots);
cerr << "done\n";
cerr << "Encoding direct votes...\n";
vector<PlaintextArray> votesEncoded = encodeVotes(votes, ea);
cerr << "Encrypting direct votes...\n";
vector<Ctxt> votesEncrypted = encryptVotes(votesEncoded, ea, publicKey);
cerr << "Reading delegations";
vector<vector <long> > delegations = readVotes("delegations.txt", nslots);
cerr << "done\n";
cerr << "Encoding delegations...\n";
vector<PlaintextArray> delegationsEncoded = encodeVotes(delegations, ea);
cerr << "Encrypting delegations...\n";
vector<Ctxt> delegationsEncrypted = encryptVotes(delegationsEncoded, ea, publicKey);
cerr << "Tallying delegations (+)...\n";
Ctxt delegateWeights = tallyVotes(delegationsEncrypted);
vector<Ctxt> weightFactors = getWeightFactors(delegateWeights, ea, publicKey, delegateLimit);
cerr << "Applying weights (x)...\n";
vector<Ctxt> weightedDelegateVotes = applyWeights(weightFactors, delegateVotesEncrypted, ea, secretKey);
cerr << "Tallying direct votes (+)...\n";
Ctxt directTally = tallyVotes(votesEncrypted);
cerr << "Final tally (+)...\n";
Ctxt tally = liquidTally(directTally, weightedDelegateVotes);
cerr << "Decrypting final tally...\n";
PlaintextArray totals = decrypt(tally, ea, secretKey);
printTally(totals);
}
int main(int argc, char **argv)
{
/* On our trusted system we generate a new key
* (or read one in) and encrypt the secret data set.
*/
long m=0, p=2, r=1; // Native plaintext space
// Computations will be 'modulo p'
long L=16; // Levels
long c=3; // Columns in key switching matrix
long w=64; // Hamming weight of secret key
long d=0;
long security = 128;
ZZX G;
m = FindM(security,L,c,p, d, 0, 0);
FHEcontext context(m, p, r);
// initialize context
buildModChain(context, L, c);
// modify the context, adding primes to the modulus chain
FHESecKey secretKey(context);
// construct a secret key structure
const FHEPubKey& publicKey = secretKey;
// an "upcast": FHESecKey is a subclass of FHEPubKey
//if(0 == d)
G = context.alMod.getFactorsOverZZ()[0];
secretKey.GenSecKey(w);
// actually generate a secret key with Hamming weight w
addSome1DMatrices(secretKey);
cout << "Generated key..." << endl;
EncryptedArray ea(context, G);
// constuct an Encrypted array object ea that is
// associated with the given context and the polynomial G
long nslots = ea.size();
cout << "Vector Size " << nslots << endl;;
vector<long> v1;
for(int i = 0 ; i < nslots; i++) {
v1.push_back(1);
//v1.push_back(i*2);
}
Ctxt ct1(publicKey);
startFHEtimer("ea.encrypt1");
ea.encrypt(ct1, publicKey, v1);
stopFHEtimer("ea.encrypt1");
vector<long> v2;
Ctxt ct2(publicKey);
for(int i = 0 ; i < nslots; i++) {
v2.push_back(1);
//v2.push_back(i*3);
}
startFHEtimer("ea.encrypt2");
ea.encrypt(ct2, publicKey, v2);
stopFHEtimer("ea.encrypt2");
// v1.mul(v2); // c3.multiplyBy(c2)
// ct2.multiplyBy(ct1);
// CheckCtxt(ct2, "c3*=c2");
// debugCompare(ea,secretKey,v1,ct2);
// On the public (untrusted) system we
// can now perform our computation
Ctxt ctSum = ct1;
Ctxt ctProd = ct1;
startFHEtimer("sum");
ctSum += ct2;
stopFHEtimer("sum");
//ctProd *= ct2;
startFHEtimer("product");
ctProd *= ct2;
//ctProd.multiplyBy(ct2);
stopFHEtimer("product");
//ea.mat_mul(ctProd,ct2);
vector<long> res;
startFHEtimer("decryptsum");
ea.decrypt(ctSum, secretKey, res);
stopFHEtimer("decryptsum");
//cout << "All computations are modulo " << p << "." << endl;
for (unsigned int i = 0; i<res.size(); i++){
cout<< res[i];
}
for(unsigned int i = 0; i < res.size(); i++) {
cout << v1[i] << " + " << v2[i] << " = " << res[i] << endl;
}
startFHEtimer("decryptproduct");
ea.decrypt(ctProd, secretKey, res);
stopFHEtimer("decryptproduct");
for (unsigned int i = 0; i<res.size(); i++){
cout<< res[i];
}
for(unsigned int i = 0; i < res.size(); i++) {
cout << v1[i] << " * " << v2[i] << " = " << res[i] << endl;
}
printAllTimers();
cout << endl;
cout << "All computations are modulo " << p << "." << endl;
return 0;
}
int main(int argc, char **argv)
{
string inp = "secrets! very secrets!";
cout << "inp = \"" << inp << "\"" << endl;
vector<pt_key32> k = pt_genKey();
pt_expandKey(k);
printKey(k);
// initialize helib
long m=0, p=2, r=1;
long L=23;
long c=3;
long w=64;
long d=0;
long security = 128;
cout << "L=" << L << endl;
ZZX G;
cout << "Finding m..." << endl;
m = FindM(security,L,c,p,d,0,0);
cout << "Generating context..." << endl;
FHEcontext context(m, p, r);
cout << "Building mod-chain..." << endl;
buildModChain(context, L, c);
cout << "Generating keys..." << endl;
FHESecKey seckey(context);
const FHEPubKey& pubkey = seckey;
G = context.alMod.getFactorsOverZZ()[0];
seckey.GenSecKey(w);
addSome1DMatrices(seckey);
EncryptedArray ea(context, G);
global_nslots = ea.size();
cout << "nslots = " << global_nslots << endl;
// set up globals
CTvec maxint (ea, pubkey, transpose(uint32ToBits(0xFFFFFFFF)));
global_maxint = &maxint;
// HEencrypt key
timer(true);
cout << "Encrypting SIMON key..." << flush;
vector<CTvec> encryptedKey = heEncrypt(ea, pubkey, k);
timer();
// HEencrypt input
cout << "Encrypting inp..." << flush;
heblock ct = heEncrypt(ea, pubkey, inp);
timer();
cout << "Running protocol..." << endl;
for (size_t i = 0; i < T; i++) {
cout << "Round " << i+1 << "/" << T << "..." << flush;
encRound(encryptedKey[i], ct);
timer();
// check intermediate result for noise
cout << "decrypting..." << flush;
vector<pt_block> bs = heblockToBlocks(seckey, ct);
timer();
printf("block0 : 0x%08x 0x%08x\n", bs[0].x, bs[0].y);
vector<pt_block> pt_bs = pt_simonEnc(k, inp, i+1);
printf("should be : 0x%08x 0x%08x\n", pt_bs[0].x, pt_bs[0].y);
cout << "decrypted : \"" << pt_simonDec(k, bs, i+1) << "\" " << endl;
}
return 0;
}
int main(){
long m, r, p, L, c, w, s, d, security, enc, dec, encMul, recommended;
char tempChar;
bool toPrint = false, toSave = false;
//Scan parameters
cout << "Enter HElib's keys paramter. Enter zero for the recommended values" << endl;
while(true){
cout << "Enter the field of the computations (a prime number): ";
cin >> p;
if(isPrime(p))
break;
cout << "Error! p must be a prime number! " << endl;
}
while(true){
recommended = 1;
cout << "Enter r (recommended " << recommended <<"): ";
cin >> r;
if(r == 0)
r = recommended;
if(r > 0)
break;
cout << "Error! r must be a positive number!" << endl;
}
while(true){
recommended = 16;
cout << "Enter L (recommended " << recommended <<"): ";
cin >> L;
if(L == 0)
L = recommended;
if(L > 1)
break;
cout << "Error! L must be a positive number!" << endl;
}
while(true){
recommended = 3;
cout << "Enter c (recommended " << recommended <<"): ";
cin >> c;
if(c == 0)
c = recommended;
if(c > 1)
break;
cout << "Error! c must be a positive number!" << endl;
}
while(true){
recommended = 64;
cout << "Enter w (recommended " << recommended <<"): ";
cin >> w;
if(w == 0)
w = recommended;
if(w > 1)
break;
cout << "Error! w must be a positive number!" << endl;
}
while(true){
recommended = 0;
cout << "Enter d (recommended " << recommended <<"): ";
cin >> d;
if(d >= 0)
break;
cout << "Error! d must be a positive or zero!" << endl;
}
while(true){
recommended = 0;
cout << "Enter s (recommended " << recommended <<"): ";
cin >> s;
if(s >= 0)
break;
cout << "Error! s must be a positive or zero!" << endl;
}
while(true){
recommended = 128;
cout << "Enter security (recommended " << recommended << "): ";
cin >> security;
if(security == 0)
security = recommended;
if(security >= 1)
break;
cout << "Error! security must be a positive number " << endl;
}
ZZX G;
m = FindM(security,L,c,p, d, s, 0);
FHEcontext context(m, p, r);
// initialize context
buildModChain(context, L, c);
// modify the context, adding primes to the modulus chain
FHESecKey secretKey(context);
// construct a secret key structure
const FHEPubKey& publicKey = secretKey;
// an "upcast": FHESecKey is a subclass of FHEPubKey
//if(0 == d)
G = context.alMod.getFactorsOverZZ()[0];
secretKey.GenSecKey(w);
// actually generate a secret key with Hamming weight w
addSome1DMatrices(secretKey);
EncryptedArray ea(context, G);
// constuct an Encrypted array object ea that is
// associated with the given context and the polynomial G
long nslots = ea.size(), field = power(p,r);
cout << "nslots: " << nslots << endl ;
cout << "Computations will be modulo " << field << endl;
cout << "m: " << m << endl;
unsigned int sz1, sz2, num;
while(true){
cout << "Enter number of rows in the matrix: ";
cin >> sz1;
if(sz1 > 1 && sz1 <= nslots)
break;
cout << "Error! the value must be between 1 to " << nslots << "!" << endl;
}
while(true){
cout << "Enter number of columns in the matrix: ";
cin >> sz2;
if(sz1 > 2 && sz2 <= nslots)
break;
cout << "Error! the value must be between 1 to " << nslots << "!" << endl;
}
cout << "Enter the number you want to multiply the matrix by: ";
cin >> num;
MatSize sz(sz1, sz2);
PTMatrix PTmat(sz,field); //random matrix in size origSize1
while(true){
cout << "Print the matrices?" << endl;
cout << "Y for yes, N for no: ";
cin >> tempChar;
if(tempChar == 'Y' || tempChar == 'y'){
toPrint = true;
break;
}
if(tempChar == 'N' || tempChar == 'n'){
toPrint = false;
break;
}
cout << "Error! invalid input!" << endl;
}
while(true){
cout << "Save the matrices?" << endl;
cout << "Y for yes, N for no: ";
cin >> tempChar;
if(tempChar == 'Y' || tempChar == 'y'){
toSave = true;
break;
}
if(tempChar == 'N' || tempChar == 'n'){
toSave = false;
break;
}
cout << "Error! invalid input!" << endl;
}
if(toPrint)
PTmat.print();
if(toSave){
ofstream out_mat("mat.txt");
PTmat.save(out_mat);
out_mat.close();
}
//encryptions
cout << "Encrypting the matrix..." << endl;
resetTimers();
EncryptedMatrix encMat = PTmat.encrypt(ea, publicKey);
enc = stopTimers("to encrypt the first matrix");
//Multiply by constant
cout << "Multiplying the matricex by constant..." << endl;
resetTimers();
encMat *= num;
encMul = stopTimers("to multiply the matrix");
cout << "Decrypting the result..." << endl;
resetTimers();
PTMatrix res = encMat.decrypt(ea, secretKey);
dec = stopTimers("to decrypt the result");
if(toPrint)
res.print("Solution: ");
PTMatrix PTres = PTmat;
for(unsigned int i=1; i < num; i++){
PTres += PTmat;
}
PTres %= field;
if(toPrint)
PTres.print("pt Solution: ");
if(toSave){
ofstream out_res("mat_res.txt"), out_ptRes("mat_pt_res.txt");
res.save(out_res);
PTres.save(out_ptRes);
out_res.close(); out_ptRes.close();
}
//PTres.print("pt result: ");
cout << "\n\n----------------------------------------Summary------------------------------ " << endl;
cout << "p: " << p << ", r: " << r << ", L: " << L << ", c: " << c << ", w: " << w << ", d: " << d << ", s: " << s << ", security: " << security << endl;
cout << "nslots: " << nslots << "\nm: " << m << endl;
cout << "It took " << enc << " clock ticks to encrypt the matrix" << endl;
cout << "It took " << dec << " clock ticks to decrypt the result" << endl;
cout << "It took " << encMul << " clock ticks to add the encrypted matrices" << endl;
cout << "is correct? " << (res==PTres) << endl;
return 0;
}
