int main(int argc, char *argv[]) { long m, p, r, L, R; ArgMapping argmap; MDL::Timer timer; argmap.arg("m", m, "m"); argmap.arg("L", L, "L"); argmap.arg("p", p, "p"); argmap.arg("r", r, "r"); argmap.arg("R", R, "R"); argmap.parse(argc, argv); timer.start(); FHEcontext context(m, p, r); buildModChain(context, L); FHESecKey sk(context); sk.GenSecKey(64); addSome1DMatrices(sk); FHEPubKey pk = sk; auto G = context.alMod.getFactorsOverZZ()[0]; EncryptedArray ea(context, G); timer.end(); printf("slots %ld\n", ea.size()); printf("Key Gen %f\n", timer.second()); auto data = load_csv("adult.data", R); benchmark(ea, pk, sk, data); }
int main(int argc, char *argv[]) { #ifdef USE_NETWORK ArgMapping mapping; long role = 0; std::string host = "127.0.0.1"; mapping.arg("m", gM, "m"); mapping.arg("p", gP, "p"); mapping.arg("r", gR, "r"); mapping.arg("L", gL, "L"); mapping.arg("R", role, "role, 0:server, 1:client"); mapping.arg("H", host, "host"); mapping.arg("C", gC, "cipher to send"); mapping.parse(argc, argv); if (role == 0) { int sock = nn_socket(AF_SP, NN_REP); if (nn_bind(sock, "tcp://*:12345") < 0) { printf("%s\n", nn_strerror(errno)); return -1; } printf("SID %d\n", sock); act_server(sock); } else if (role == 1){ int sock = nn_socket(AF_SP, NN_REQ); std::string h = "tcp://" + host + ":12345"; if (nn_connect(sock, h.c_str()) < 0) { printf("%s\nn", nn_strerror(errno)); return -1; } printf("SID %d\n", sock); act_client(sock); } #endif return 0; }
int main(int argc, char *argv[]) { ArgMapping amap; long m=17; amap.arg("m", m, "cyclotomic index"); amap.note("e.g., m=2047"); long p=2; amap.arg("p", p, "plaintext base"); long r=1; amap.arg("r", r, "lifting"); Vec<long> gens0; amap.arg("gens", gens0, "use specified vector of generators", NULL); amap.note("e.g., gens='[562 1871 751]'"); Vec<long> ords0; amap.arg("ords", ords0, "use specified vector of orders", NULL); amap.note("e.g., ords='[4 2 -4]', negative means 'bad'"); amap.parse(argc, argv); cout << "m = " << m << ", p = " << p << ", r = " << r << endl; vector<long> f; factorize(f,m); cout << "factoring "<<m<<" gives ["; for (unsigned long i=0; i<f.size(); i++) cout << f[i] << " "; cout << "]\n"; vector<long> gens1, ords1; convert(gens1, gens0); convert(ords1, ords0); PAlgebra al(m, p, gens1, ords1); al.printout(); cout << "\n"; PAlgebraMod almod(al, r); FHEcontext context(m, p, r); buildModChain(context, 5, 2); stringstream s1; writeContextBase(s1, context); s1 << context; string s2 = s1.str(); cout << s2 << endl; stringstream s3(s2); unsigned long m1, p1, r1; vector<long> gens, ords; readContextBase(s3, m1, p1, r1, gens, ords); FHEcontext c1(m1, p1, r1, gens, ords); s3 >> c1; if (context == c1) cout << "equal\n"; else cout << "not equal\n"; return 0; }
int main(int argc, char *argv[]) { // Commandline setup ArgMapping amap; long m=16; long r=8; long L=0; double epsilon=0.01; // Accepted accuracy long R=1; long seed=0; bool debug = false; amap.arg("m", m, "Cyclotomic index"); amap.note("e.g., m=1024, m=2047"); amap.arg("r", r, "Bits of precision"); amap.arg("R", R, "number of rounds"); amap.arg("L", L, "Number of bits in modulus", "heuristic"); amap.arg("ep", epsilon, "Accepted accuracy"); amap.arg("seed", seed, "PRG seed"); amap.arg("verbose", verbose, "more printouts"); amap.arg("debug", debug, "for debugging"); amap.parse(argc, argv); if (seed) NTL::SetSeed(ZZ(seed)); if (R<=0) R=1; if (R<=2) L = 100*R; else L = 220*(R-1); if (verbose) { cout << "** m="<<m<<", #rounds="<<R<<", |q|="<<L << ", epsilon="<<epsilon<<endl; } epsilon /= R; try{ // FHE setup keys, context, SKMs, etc FHEcontext context(m, /*p=*/-1, r); context.scale=4; buildModChain(context, L, /*c=*/2); FHESecKey secretKey(context); secretKey.GenSecKey(); // A +-1/0 secret key addSome1DMatrices(secretKey); // compute key-switching matrices const FHEPubKey publicKey = secretKey; const EncryptedArrayCx& ea = context.ea->getCx(); if (verbose) { ea.getPAlgebra().printout(); cout << "r = " << context.alMod.getR() << endl; cout << "ctxtPrimes="<<context.ctxtPrimes << ", specialPrimes="<<context.specialPrimes<<endl<<endl; } if (debug) { dbgKey = & secretKey; dbgEa = (EncryptedArray*) context.ea; } // Run the tests. testBasicArith(publicKey, secretKey, ea, epsilon); testComplexArith(publicKey, secretKey, ea, epsilon); testRotsNShifts(publicKey, secretKey, ea, epsilon); testGeneralOps(publicKey, secretKey, ea, epsilon*R, R); } catch (exception& e) { cerr << e.what() << endl; cerr << "***Major FAIL***" << endl; } return 0; }
// Testing the I/O of the important classes of the library // (context, keys, ciphertexts). int main(int argc, char *argv[]) { ArgMapping amap; long r=1; long p=2; long c = 2; long w = 64; long L = 5; long mm=0; amap.arg("p", p, "plaintext base"); amap.arg("r", r, "lifting"); amap.arg("c", c, "number of columns in the key-switching matrices"); amap.arg("m", mm, "cyclotomic index","{31,127,1023}"); amap.parse(argc, argv); bool useTable = (mm==0 && p==2); long ptxtSpace = power_long(p,r); long numTests = useTable? N_TESTS : 1; std::unique_ptr<FHEcontext> contexts[numTests]; std::unique_ptr<FHESecKey> sKeys[numTests]; std::unique_ptr<Ctxt> ctxts[numTests]; std::unique_ptr<EncryptedArray> eas[numTests]; vector<ZZX> ptxts[numTests]; // first loop: generate stuff and write it to cout // open file for writing {fstream keyFile("iotest.txt", fstream::out|fstream::trunc); assert(keyFile.is_open()); for (long i=0; i<numTests; i++) { long m = (mm==0)? ms[i][1] : mm; cout << "Testing IO: m="<<m<<", p^r="<<p<<"^"<<r<<endl; Vec<long> mvec(INIT_SIZE,2); mvec[0] = ms[i][4]; mvec[1] = ms[i][5]; vector<long> gens(2); gens[0] = ms[i][6]; gens[1] = ms[i][7]; vector<long> ords(2); ords[0] = ms[i][8]; ords[1] = ms[i][9]; if (useTable && gens[0]>0) contexts[i].reset(new FHEcontext(m, p, r, gens, ords)); else contexts[i].reset(new FHEcontext(m, p, r)); contexts[i]->zMStar.printout(); buildModChain(*contexts[i], L, c); // Set the modulus chain if (mm==0 && m==1023) contexts[i]->makeBootstrappable(mvec); // Output the FHEcontext to file writeContextBase(keyFile, *contexts[i]); writeContextBase(cout, *contexts[i]); keyFile << *contexts[i] << endl; sKeys[i].reset(new FHESecKey(*contexts[i])); const FHEPubKey& publicKey = *sKeys[i]; sKeys[i]->GenSecKey(w,ptxtSpace); // A Hamming-weight-w secret key addSome1DMatrices(*sKeys[i]);// compute key-switching matrices that we need eas[i].reset(new EncryptedArray(*contexts[i])); long nslots = eas[i]->size(); // Output the secret key to file, twice. Below we will have two copies // of most things. keyFile << *sKeys[i] << endl;; keyFile << *sKeys[i] << endl;; vector<ZZX> b; long p2r = eas[i]->getContext().alMod.getPPowR(); ZZX poly = RandPoly(0,to_ZZ(p2r)); // choose a random constant polynomial eas[i]->decode(ptxts[i], poly); ctxts[i].reset(new Ctxt(publicKey)); eas[i]->encrypt(*ctxts[i], publicKey, ptxts[i]); eas[i]->decrypt(*ctxts[i], *sKeys[i], b); assert(ptxts[i].size() == b.size()); for (long j = 0; j < nslots; j++) assert (ptxts[i][j] == b[j]); // output the plaintext keyFile << "[ "; for (long j = 0; j < nslots; j++) keyFile << ptxts[i][j] << " "; keyFile << "]\n"; eas[i]->encode(poly,ptxts[i]); keyFile << poly << endl; // Output the ciphertext to file keyFile << *ctxts[i] << endl; keyFile << *ctxts[i] << endl; cerr << "okay " << i << endl<< endl; } keyFile.close();} cerr << "so far, so good\n\n"; // second loop: read from input and repeat the computation // open file for read {fstream keyFile("iotest.txt", fstream::in); for (long i=0; i<numTests; i++) { // Read context from file unsigned long m1, p1, r1; vector<long> gens, ords; readContextBase(keyFile, m1, p1, r1, gens, ords); FHEcontext tmpContext(m1, p1, r1, gens, ords); keyFile >> tmpContext; assert (*contexts[i] == tmpContext); cerr << i << ": context matches input\n"; // We define some things below wrt *contexts[i], not tmpContext. // This is because the various operator== methods check equality of // references, not equality of the referenced FHEcontext objects. FHEcontext& context = *contexts[i]; FHESecKey secretKey(context); FHESecKey secretKey2(tmpContext); const FHEPubKey& publicKey = secretKey; const FHEPubKey& publicKey2 = secretKey2; keyFile >> secretKey; keyFile >> secretKey2; assert(secretKey == *sKeys[i]); cerr << " secret key matches input\n"; EncryptedArray ea(context); EncryptedArray ea2(tmpContext); long nslots = ea.size(); // Read the plaintext from file vector<ZZX> a; a.resize(nslots); assert(nslots == (long)ptxts[i].size()); seekPastChar(keyFile, '['); // defined in NumbTh.cpp for (long j = 0; j < nslots; j++) { keyFile >> a[j]; assert(a[j] == ptxts[i][j]); } seekPastChar(keyFile, ']'); cerr << " ptxt matches input\n"; // Read the encoded plaintext from file ZZX poly1, poly2; keyFile >> poly1; eas[i]->encode(poly2,a); assert(poly1 == poly2); cerr << " eas[i].encode(a)==poly1 okay\n"; ea.encode(poly2,a); assert(poly1 == poly2); cerr << " ea.encode(a)==poly1 okay\n"; ea2.encode(poly2,a); assert(poly1 == poly2); cerr << " ea2.encode(a)==poly1 okay\n"; eas[i]->decode(a,poly1); assert(nslots == (long)a.size()); for (long j = 0; j < nslots; j++) assert(a[j] == ptxts[i][j]); cerr << " eas[i].decode(poly1)==ptxts[i] okay\n"; ea.decode(a,poly1); assert(nslots == (long)a.size()); for (long j = 0; j < nslots; j++) assert(a[j] == ptxts[i][j]); cerr << " ea.decode(poly1)==ptxts[i] okay\n"; ea2.decode(a,poly1); assert(nslots == (long)a.size()); for (long j = 0; j < nslots; j++) assert(a[j] == ptxts[i][j]); cerr << " ea2.decode(poly1)==ptxts[i] okay\n"; // Read ciperhtext from file Ctxt ctxt(publicKey); Ctxt ctxt2(publicKey2); keyFile >> ctxt; keyFile >> ctxt2; assert(ctxts[i]->equalsTo(ctxt,/*comparePkeys=*/false)); cerr << " ctxt matches input\n"; sKeys[i]->Decrypt(poly2,*ctxts[i]); assert(poly1 == poly2); cerr << " sKeys[i]->decrypt(*ctxts[i]) == poly1 okay\n"; secretKey.Decrypt(poly2,*ctxts[i]); assert(poly1 == poly2); cerr << " secretKey.decrypt(*ctxts[i]) == poly1 okay\n"; secretKey.Decrypt(poly2,ctxt); assert(poly1 == poly2); cerr << " secretKey.decrypt(ctxt) == poly1 okay\n"; secretKey2.Decrypt(poly2,ctxt2); assert(poly1 == poly2); cerr << " secretKey2.decrypt(ctxt2) == poly1 okay\n"; eas[i]->decrypt(ctxt, *sKeys[i], a); assert(nslots == (long)a.size()); for (long j = 0; j < nslots; j++) assert(a[j] == ptxts[i][j]); cerr << " eas[i].decrypt(ctxt, *sKeys[i])==ptxts[i] okay\n"; ea.decrypt(ctxt, secretKey, a); assert(nslots == (long)a.size()); for (long j = 0; j < nslots; j++) assert(a[j] == ptxts[i][j]); cerr << " ea.decrypt(ctxt, secretKey)==ptxts[i] okay\n"; ea2.decrypt(ctxt2, secretKey2, a); assert(nslots == (long)a.size()); for (long j = 0; j < nslots; j++) assert(a[j] == ptxts[i][j]); cerr << " ea2.decrypt(ctxt2, secretKey2)==ptxts[i] okay\n"; cerr << "test "<<i<<" okay\n\n"; }} unlink("iotest.txt"); // clean up before exiting }
/* Usage: Test_EvalMap_x.exe [ name=value ]... * p plaintext base [ default=2 ] * r lifting [ default=1 ] * c number of columns in the key-switching matrices [ default=2 ] * k security parameter [ default=80 ] * L # of bits in the modulus chain * s minimum number of slots [ default=0 ] * seed PRG seed [ default=0 ] * mvec use specified factorization of m * e.g., mvec='[5 3 187]' * gens use specified vector of generators * e.g., gens='[562 1871 751]' * ords use specified vector of orders * e.g., ords='[4 2 -4]', negative means 'bad' */ int main(int argc, char *argv[]) { ArgMapping amap; long p=2; amap.arg("p", p, "plaintext base"); long r=1; amap.arg("r", r, "lifting"); long c=2; amap.arg("c", c, "number of columns in the key-switching matrices"); long k=80; amap.arg("k", k, "security parameter"); long L=300; amap.arg("L", L, "# of bits in the modulus chain"); long s=0; amap.arg("s", s, "minimum number of slots"); long seed=0; amap.arg("seed", seed, "PRG seed"); Vec<long> mvec; amap.arg("mvec", mvec, "use specified factorization of m", NULL); amap.note("e.g., mvec='[7 3 221]'"); Vec<long> gens; amap.arg("gens", gens, "use specified vector of generators", NULL); amap.note("e.g., gens='[3979 3095 3760]'"); Vec<long> ords; amap.arg("ords", ords, "use specified vector of orders", NULL); amap.note("e.g., ords='[6 2 -8]', negative means 'bad'"); amap.arg("dry", dry, "a dry-run flag to check the noise"); long nthreads=1; amap.arg("nthreads", nthreads, "number of threads"); amap.arg("noPrint", noPrint, "suppress printouts"); long useCache=0; amap.arg("useCache", useCache, "0: zzX cache, 2: DCRT cache"); amap.parse(argc, argv); SetNumThreads(nthreads); SetSeed(conv<ZZ>(seed)); TestIt(p, r, c, k, L, mvec, gens, ords, useCache); }
NTL_CLIENT //namespace NTL { extern double ip_time; } int main(int argc, char **argv) { ArgMapping amap; long n = 1024; amap.arg("n", n, "degree bound"); long l = 1024; amap.arg("l", l, "coeff bound"); long nt = 1; amap.arg("nt", nt, "num threads"); amap.parse(argc, argv); cerr << "\n\n=============================\n\n"; cerr << "n=" << n << "\n"; cerr << "l=" << l << "\n"; cerr << "nt=" << nt << "\n"; SetSeed(ZZ(0)); SetNumThreads(nt); ZZ p; RandomPrime(p, l); ZZ_p::init(p); ZZ_pX f; random(f, n); SetCoeff(f, n); Vec< Pair<ZZ_pX, long> > fac; double t; ZZ_pXFileThresh = 1e9; FILE *fp; unsigned long A[4], B[4]; int loadavg; fp = fopen("/proc/stat","r"); fscanf(fp,"cpu %lu %lu %lu %lu",&A[0],&A[1],&A[2],&A[3]); fclose(fp); t = GetTime(); CanZass(fac, f, 1); t = GetTime()-t; double NTLTime = t; fp = fopen("/proc/stat","r"); fscanf(fp,"cpu %lu %lu %lu %lu",&B[0],&B[1],&B[2],&B[3]); fclose(fp); // we multiply by 20 -- that's the total number of cores loadavg = int(100.0*20.0*double((B[0]+B[1]+B[2]) - (A[0]+A[1]+A[2])) / double((B[0]+B[1]+B[2]+B[3]) - (A[0]+A[1]+A[2]+A[3]))); fprintf(stderr, "CPU utilization: %d\%\n",loadavg); struct rusage rusage; getrusage( RUSAGE_SELF, &rusage ); cerr << "MAX_RSS="<<rusage.ru_maxrss << "KB" << endl; cerr << "Fac: " << t << "\n"; //cerr << "ip_time: " << ip_time << "\n"; delete NTLThreadPool; NTLThreadPool = 0; }
int main(int argc, char *argv[]) { ArgMapping amap; long p=2; long r=1; long c=3; long L=600; long N=0; long t=0; long nthreads=1; long seed=0; long useCache=1; amap.arg("p", p, "plaintext base"); amap.arg("r", r, "exponent"); amap.note("p^r is the plaintext-space modulus"); amap.arg("c", c, "number of columns in the key-switching matrices"); amap.arg("L", L, "# of levels in the modulus chain"); amap.arg("N", N, "lower-bound on phi(m)"); amap.arg("t", t, "Hamming weight of recryption secret key", "heuristic"); amap.arg("dry", dry, "dry=1 for a dry-run"); amap.arg("nthreads", nthreads, "number of threads"); amap.arg("seed", seed, "random number seed"); amap.arg("noPrint", noPrint, "suppress printouts"); amap.arg("useCache", useCache, "0: zzX cache, 1: DCRT cache"); amap.arg("force_bsgs", fhe_test_force_bsgs); amap.arg("force_hoist", fhe_test_force_hoist); // amap.arg("disable_intFactor", fhe_disable_intFactor); amap.arg("chen_han", fhe_force_chen_han); amap.arg("debug", debug, "generate debugging output"); amap.arg("scale", scale, "scale parameter"); amap.parse(argc, argv); if (seed) SetSeed(ZZ(seed)); SetNumThreads(nthreads); for (long i=0; i<(long)num_mValues; i++) if (mValues[i][0]==p && mValues[i][1]>=N) { TestIt(i,p,r,L,c,t,useCache); break; } return 0; }
int main(int argc, char *argv[]) { ArgMapping amap; bool dry=false; amap.arg("dry", dry, "dry=1 for a dry-run"); long m=2047; amap.arg("m", m, "cyclotomic ring"); long p=2; amap.arg("p", p, "plaintext base"); long r=1; amap.arg("r", r, "lifting"); long d=1; amap.arg("d", d, "degree of the field extension"); amap.note("d == 0 => factors[0] defines extension"); long L=3; amap.arg("L", L, "# of levels in the modulus chain", "heuristic"); long bnd = 64; amap.arg("bnd", bnd, "recursion bound for replication"); long B = 0; amap.arg("B", B, "bound for # of replications", "all"); amap.parse(argc, argv); setDryRun(dry); TestIt(m, p, r, d, L, bnd, B); cout << endl; }
int main(int argc, char *argv[]) { ArgMapping amap; amap.arg("noPrint", noPrint, "suppress printouts"); long m=16; amap.arg("m", m, "cyclotomic index"); amap.note("e.g., m=1024, m=2047"); long r=8; amap.arg("r", r, "bit of precision"); amap.parse(argc, argv); if (!noPrint) { vector<long> f; factorize(f,m); cout << "r="<<r<<", factoring "<<m<<" gives ["; for (unsigned long i=0; i<f.size(); i++) cout << f[i] << " "; cout << "]\n"; } FHEcontext context(m, /*p=*/-1, r); buildModChain(context, 5, 2); const EncryptedArrayCx& ea = context.ea->getCx(); if (!noPrint) ea.getPAlgebra().printout(); #ifdef DEBUG_PRINTOUT vector<cx_double> vc1; ea.random(vc1); cout << "random complex vc1="; printVec(cout,vc1,8)<<endl; vector<double> vd; ea.random(vd); cout << "random real vd="; printVec(cout,vd,8)<<endl; #endif vector<double> vl; ea.random(vl); vl[1] = -1; // ensure that this is not the zero vector #ifdef DEBUG_PRINTOUT cout << "random int v="; printVec(cout,vl,8)<<endl; #endif zzX poly; double factor = ea.encode(poly, vl, 1.0); if (!noPrint) { ZZX poly2; convert(poly2, poly); cout << " encoded into a degree-"<<NTL::deg(poly2)<<" polynomial\n"; } vector<double> vd2; ea.decode(vd2, poly, factor); #ifdef DEBUG_PRINTOUT cout << " decoded into vd2="; printVec(cout,vd2,8)<<endl; #endif assert(lsize(vl)==lsize(vd2)); double maxDiff = 0.0; for (long i=0; i<lsize(vl); i++) { double diffAbs = std::abs(vl[i]-vd2[i]); if (diffAbs > maxDiff) maxDiff = diffAbs; } cout << ((maxDiff>0.1)? "BAD?" : "GOOD?") << " max |v-vd2|_{infty}="<<maxDiff << endl; return 0; }
int main(int argc, char *argv[]) { ArgMapping amap; long m=53; amap.arg("m", m, "use specified value as modulus"); long p=17; amap.arg("p", p, "plaintext base"); long r=1; amap.arg("r", r, "lifting"); long levels=5; amap.arg("L", levels, "levels"); long nb_coeffs=5; amap.arg("n", nb_coeffs, "nb coefficients to extract"); amap.parse(argc, argv); cout << "\n\n******** generate parameters" << " m=" << m << ", p=" << p << ", r=" << r << ", n=" << nb_coeffs << endl; setTimersOn(); FHEcontext context(m, p, r); buildModChain(context, /*L=*/levels); // cout << context << endl; // context.zMStar.printout(); // cout << endl; cout << "Generating keys and key-switching matrices... " << std::flush; FHESecKey secretKey(context); secretKey.GenSecKey(/*w=*/64);// A Hamming-weight-w secret key addFrbMatrices(secretKey); // compute key-switching matrices that we need add1DMatrices(secretKey); // compute key-switching matrices that we need const FHEPubKey& publicKey = secretKey; cout << "done\n"; resetAllTimers(); EncryptedArray ea = *(context.ea); ea.buildLinPolyMat(false); Ctxt ctxt(publicKey); NewPlaintextArray ptxt(ea); random(ea, ptxt); // ea.encrypt(ctxt, publicKey, ptxt); ea.skEncrypt(ctxt, secretKey, ptxt); cout << "Extracting " << nb_coeffs << " coefficients..."; vector<Ctxt> coeffs; extractCoeffs(ea, coeffs, ctxt, nb_coeffs); cout << "done\n"; vector<ZZX> ptxtDec; ea.decrypt(ctxt, secretKey, ptxtDec); for (long i=0; i<(long)coeffs.size(); i++) { if (!coeffs[i].isCorrect()) { cerr << " potential decryption error for "<<i<<"th coeffs " << endl; CheckCtxt(coeffs[i], ""); exit(0); } vector<ZZX> pCoeffs; ea.decrypt(coeffs[i], secretKey, pCoeffs); assert(pCoeffs.size() == ptxtDec.size()); for (int j = 0; j < pCoeffs.size(); ++j) { if (coeff(pCoeffs[j], 0) != coeff(ptxtDec[j], i)) { cerr << "error: extracted coefficient " << i << " from " "slot " << j << " is " << coeff(pCoeffs[j], 0) << " instead of " << coeff(ptxtDec[j], i) << endl; exit(0); } } } cerr << "Extracted coefficient successfully verified!\n"; }