a few touches

README.md

@@ -8,12 +8,12 @@ a copy of the paper [here](https://eprint.iacr.org/2017/1142.pdf).
 
 # Compiling SEAL
 
-SealPIR depends on [Microsoft SEAL version 3.2.0](https://github.com/microsoft/SEAL/tree/3.2.0).
+SealPIR depends on [Microsoft SEAL version 3.6.5](https://github.com/microsoft/SEAL/tree/3.6.5).
 Install SEAL before compiling SealPIR.
 
 # Compiling SealPIR
 
-Once Microsoft SEAL 3.2.0 is installed, to build SealPIR simply run:
+Once Microsoft SEAL 3.6.5 is installed, to build SealPIR simply run:
 
 	cmake .
 	make
@@ -23,8 +23,9 @@ This should produce a binary file ``bin/sealpir``.
 # Using SealPIR
 
 Take a look at the example in main.cpp for how to use SealPIR. 
-Note: the parameter "d" stands for recursion levels, and for the current configuration, the 
-server-to-client reply has size (pow(10, d-1) * 32) KB. Therefore we recommend using d <= 3.  
+Note: the parameter "d" stands for recursion levels, and for the current 
+configuration, the server-to-client reply has size (pow(10, d-1) * 32) KB. 
+Therefore we recommend using d <= 3.  
 
 # Contributing
 

expand_test.cpp

@@ -92,8 +92,8 @@ int main(int argc, char *argv[]) {
             return 1;
         }
         else{
-            cout << "Should be " << index << ": 1" << endl;
-            cout << i << ": " << decryption.to_string() << endl;
+            cout << "Plaintext of query vector at index " << index << " should have value 1 (check below)" << endl;
+            cout << "Plaintext of query vector at index " << i << " has value " << decryption.to_string() << endl;
         }
     }
 

main.cpp

@@ -14,11 +14,11 @@ using namespace seal;
 
 int main(int argc, char *argv[]) {
 
-    uint64_t number_of_items = 1 << 12;
+    uint64_t number_of_items = 1 << 18;
     uint64_t size_per_item = 288; // in bytes
     uint32_t N = 4096;
 
-    // Recommended values: (logt, d) = (12, 2) or (8, 1). 
+    // Recommended values: (logt, d) = (20, 2).
     uint32_t logt = 20; 
     uint32_t d = 2;
 
@@ -38,8 +38,7 @@ int main(int argc, char *argv[]) {
     gen_pir_params(number_of_items, size_per_item, d, enc_params, pir_params);
     
     
-    
-    //gen_params(number_of_items, size_per_item, N, logt, d, enc_params, pir_params);
+    print_seal_params(enc_params); 
     print_pir_params(pir_params);
 
     cout << "Main: Initializing the database (this may take some time) ..." << endl;
@@ -69,7 +68,7 @@ int main(int argc, char *argv[]) {
     GaloisKeys galois_keys = client.generate_galois_keys();
 
     // Set galois key for client with id 0
-    cout << "Main: Setting Galois keys...";
+    cout << "Main: Setting Galois keys..." << endl;
     server.set_galois_key(0, galois_keys);
 
     // Measure database setup

pir.cpp

@@ -21,9 +21,7 @@ std::vector<std::uint64_t> get_dimensions(std::uint64_t num_of_plaintexts, std::
     }
 
     std::uint32_t prod = accumulate(dimensions.begin(), dimensions.end(), 1, multiplies<uint64_t>());
-    cout << "Total:" << num_of_plaintexts << endl << "Prod: "
-     << prod << endl;
-    assert(prod > num_of_plaintexts);
+    assert(prod >= num_of_plaintexts);
     return dimensions;
 }
 
@@ -32,7 +30,7 @@ void gen_encryption_params(std::uint32_t N, std::uint32_t logt,
     
     enc_params.set_poly_modulus_degree(N);
     enc_params.set_coeff_modulus(CoeffModulus::BFVDefault(N));
-    enc_params.set_plain_modulus(PlainModulus::Batching(N, logt));
+    enc_params.set_plain_modulus(PlainModulus::Batching(N, logt+1));
 }
 
 void verify_encryption_params(const seal::EncryptionParameters &enc_params){
@@ -62,10 +60,6 @@ void gen_pir_params(uint64_t ele_num, uint64_t ele_size, uint32_t d,
     std::uint32_t N = enc_params.poly_modulus_degree();
     Modulus t = enc_params.plain_modulus();
     std::uint32_t logt = floor(log2(t.value()));
-
-    cout << "logt: " << logt << endl << "N: " << N << endl <<
-    "ele_num: " << ele_num << endl << "ele_size: " << ele_size << endl;
-
     std::uint64_t elements_per_plaintext;
     std::uint64_t num_of_plaintexts;
 
@@ -83,7 +77,6 @@ void gen_pir_params(uint64_t ele_num, uint64_t ele_size, uint32_t d,
     uint32_t expansion_ratio = 0;
     for (uint32_t i = 0; i < enc_params.coeff_modulus().size(); ++i) {
         double logqi = log2(enc_params.coeff_modulus()[i].value());
-        cout << "PIR: logqi = " << logqi << endl;
         expansion_ratio += ceil(logqi / logt);
     }
 
@@ -96,23 +89,45 @@ void gen_pir_params(uint64_t ele_num, uint64_t ele_size, uint32_t d,
     pir_params.d = d;                 
     pir_params.expansion_ratio = expansion_ratio << 1;           
     pir_params.nvec = nvec;
-    pir_params.n = num_of_plaintexts;
     pir_params.slot_count = N;
 }
 
 
 void print_pir_params(const PirParams &pir_params){
-    cout << "Pir Params: " << endl;
-    cout << "num_of_elements: " << pir_params.ele_num << endl;
-    cout << "ele_size: " << pir_params.ele_size << endl;
-    cout << "elements_per_plaintext: " << pir_params.elements_per_plaintext << endl;
-    cout << "num_of_plaintexts: " << pir_params.num_of_plaintexts << endl;
-    cout << "dimension: " << pir_params.d << endl;
+    std::uint32_t prod = accumulate(pir_params.nvec.begin(), pir_params.nvec.end(), 1, multiplies<uint64_t>());
+
+    cout << "PIR Parameters" << endl;
+    cout << "number of elements: " << pir_params.ele_num << endl;
+    cout << "element size: " << pir_params.ele_size << endl;
+    cout << "elements per BFV plaintext: " << pir_params.elements_per_plaintext << endl;
+    cout << "dimensions for d-dimensional hyperrectangle: " << pir_params.d << endl;
+    cout << "number of BFV plaintexts (before padding): " << pir_params.num_of_plaintexts << endl;
+    cout << "Number of BFV plaintexts after padding (to fill d-dimensional hyperrectangle): " << prod << endl;
     cout << "expansion ratio: " << pir_params.expansion_ratio << endl;
-    cout << "n: " << pir_params.n << endl;
     cout << "slot count: " << pir_params.slot_count << endl;
+    cout << "=============================="<< endl;
+}
+
+
+void print_seal_params(const EncryptionParameters &enc_params){
+    std::uint32_t N = enc_params.poly_modulus_degree();
+    Modulus t = enc_params.plain_modulus();
+    std::uint32_t logt = floor(log2(t.value()));
+
+    cout << "SEAL encryption parameters"  << endl;
+    cout << "Degree of polynomial modulus (N): " << N << endl;
+    cout << "Size of plaintext modulus (log t):" << logt << endl;
+    cout << "There are " << enc_params.coeff_modulus().size() << " coefficient modulus:" << endl;
+
+    for (uint32_t i = 0; i < enc_params.coeff_modulus().size(); ++i) {
+        double logqi = log2(enc_params.coeff_modulus()[i].value());
+        cout << "Size of coefficient modulus " << i << " (log q_" << i << "): " << logqi << endl;
+    }
+    cout << "=============================="<< endl;
 }
 
+
+
 uint32_t plainmod_after_expansion(uint32_t logt, uint32_t N, uint32_t d, 
         uint64_t ele_num, uint64_t ele_size) {
 
@@ -318,4 +333,4 @@ GaloisKeys *deserialize_galoiskeys(string s, shared_ptr<SEALContext> context) {
     std::istringstream input(s);
     g->unsafe_load(*context, input);
     return g;
-}
+}

pir.hpp

@@ -21,7 +21,6 @@ struct PirParams {
     std::uint32_t d;                 // number of dimensions for the database
     std::uint32_t expansion_ratio;           // ratio of ciphertext to plaintext
     std::vector<std::uint64_t> nvec;         // size of each of the d dimensions
-    std::uint32_t n;
     std::uint32_t slot_count;
 };
 
@@ -48,6 +47,7 @@ void gen_params(uint64_t ele_num,
 void verify_encryption_params(const seal::EncryptionParameters &enc_params);
 
 void print_pir_params(const PirParams &pir_params);
+void print_seal_params(const seal::EncryptionParameters &enc_params);
 
 // returns the plaintext modulus after expansion
 std::uint32_t plainmod_after_expansion(std::uint32_t logt, std::uint32_t N, 
@@ -94,4 +94,4 @@ std::string serialize_query(std::vector<std::vector<seal::Ciphertext>> c);
 
 // Serialize and deserialize galois keys to send them over the network
 std::string serialize_galoiskeys(seal::GaloisKeys g);
-seal::GaloisKeys *deserialize_galoiskeys(std::string s, std::shared_ptr<seal::SEALContext> context);
+seal::GaloisKeys *deserialize_galoiskeys(std::string s, std::shared_ptr<seal::SEALContext> context);

pir_server.cpp

@@ -53,9 +53,6 @@ void PIRServer::set_database(const std::unique_ptr<const std::uint8_t[]> &bytes,
     }
     uint64_t matrix_plaintexts = prod;
 
-    cout << "Total: " << num_of_plaintexts << endl;
-    cout << "Prod: " << prod << endl;
-
     assert(num_of_plaintexts <= matrix_plaintexts);
 
     auto result = make_unique<vector<Plaintext>>();
@@ -69,9 +66,6 @@ void PIRServer::set_database(const std::unique_ptr<const std::uint8_t[]> &bytes,
     uint64_t coeff_per_ptxt = ele_per_ptxt * coefficients_per_element(logt, ele_size);
     assert(coeff_per_ptxt <= N);
 
-    cout << "Server: num_of_plaintexts number of FV plaintext = " << num_of_plaintexts << endl;
-    cout << "Server: elements packed into each plaintext " << ele_per_ptxt << endl; 
-
     uint32_t offset = 0;
 
     for (uint64_t i = 0; i < num_of_plaintexts; i++) {
@@ -152,7 +146,6 @@ PirReply PIRServer::generate_reply(PirQuery query, uint32_t client_id) {
 
     int logt = floor(log2(enc_params_.plain_modulus().value()));
 
-    cout << "expansion ratio = " << pir_params_.expansion_ratio << endl; 
     for (uint32_t i = 0; i < nvec.size(); i++) {
         cout << "Server: " << i + 1 << "-th recursion level started " << endl;