changes with savefile

Author: adityachivu

Diff for: .gitignore

@@ -0,0 +1 @@
+.idea/

Diff for: SEAL/configure

@@ -112,6 +112,13 @@ namespace seal
         stream.write(reinterpret_cast<const char*>(ciphertext_array_.get()), size_ * poly_coeff_count_ * coeff_mod_count_ * bytes_per_uint64);
     }
 
+    void Ciphertext::python_save(std::string &path) const
+    {
+        std::ofstream out(path);
+        save(out);
+        out.close();
+    }
+
     void Ciphertext::load(istream &stream)
     {
         stream.read(reinterpret_cast<char*>(&hash_block_), sizeof(EncryptionParameters::hash_block_type));
@@ -129,6 +136,13 @@ namespace seal
         stream.read(reinterpret_cast<char*>(ciphertext_array_.get()), size_ * poly_coeff_count_ * coeff_mod_count_ * bytes_per_uint64);
     }
 
+    void Ciphertext::python_load(std::string &path)
+    {
+        std::ifstream in(path);
+        load(in);
+        in.close();
+    }
+
     void Ciphertext::resize(int size, int poly_coeff_count, int coeff_mod_count, const MemoryPoolHandle &pool)
     {
         if (size < 2)

Diff for: SEAL/seal/ciphertext.cpp

@@ -2,6 +2,7 @@
 
 #include <string>
 #include <iostream>
+#include <fstream>
 #include "seal/util/uintcore.h"
 #include "seal/encryptionparams.h"
 #include "seal/memorypoolhandle.h"
@@ -485,15 +486,15 @@ namespace seal
         @see load() to load a saved ciphertext.
         */
         void save(std::ostream &stream) const;
-
+        void python_save(std::string &path) const;
         /**
         Loads a ciphertext from an input stream overwriting the current ciphertext.
 
         @param[in] stream The stream to load the ciphertext from
         @see save() to save a ciphertext.
         */
         void load(std::istream &stream);
-
+        void python_load(std::string &path);
         /**
         Returns a constant reference to the hash block.
 

Diff for: SEAL/seal/ciphertext.h

@@ -160,7 +160,12 @@ PYBIND11_MODULE(seal, m) {
         "Allocates enough memory to accommodate the backing array of a ciphertext with given capacity")
     .def("reserve", (void (Ciphertext::*)(const EncryptionParameters &, int, const MemoryPoolHandle &)) &Ciphertext::reserve,
         "Allocates enough memory to accommodate the backing array of a ciphertext with given capacity")
-    .def("size", &Ciphertext::size, "Returns the capacity of the allocation");
+    .def("size", &Ciphertext::size, "Returns the capacity of the allocation")
+    .def("python_save", (void (Ciphertext::*)(std::string &)) &Ciphertext::python_save,
+        "Saves Ciphertext object to file given filepath")
+    .def("python_load", (void (Ciphertext::*)(std::string &)) &Ciphertext::python_load,
+        "Loads Ciphertext object from file given filepath");
+
 
   py::class_<Decryptor>(m, "Decryptor")
     .def(py::init<const SEALContext &, const SecretKey &>())
@@ -463,4 +468,5 @@ PYBIND11_MODULE(seal, m) {
 
   m.def("coeff_modulus_128", &coeff_modulus_128, "Returns the default coefficients modulus for a given polynomial modulus degree.");
   m.def("dbc_max", &dbc_max, "Return dbc max value.");
+
 }

Diff for: SEALPython/wrapper.cpp

@@ -1539,24 +1539,165 @@ def performance_test_mt(th_index, lock, pool):
         th_vector[i].join()
 
 
+
+def save_example():
+
+    print_example_banner("Example: Basics I");
+
+   
+    parms = EncryptionParameters()
+
+    # We first set the polynomial modulus. This must be a power-of-2 cyclotomic
+    # polynomial, i.e. a polynomial of the form "1x^(power-of-2) + 1". The polynomial
+    # modulus should be thought of mainly affecting the security level of the scheme;
+    # larger polynomial modulus makes the scheme more secure. At the same time, it
+    # makes ciphertext sizes larger, and consequently all operations slower.
+    # Recommended degrees for poly_modulus are 1024, 2048, 4096, 8192, 16384, 32768,
+    # but it is also possible to go beyond this. Since we perform only a very small
+    # computation in this example, it suffices to use a very small polynomial modulus
+    parms.set_poly_modulus("1x^2048 + 1")
+
+   
+    parms.set_coeff_modulus(seal.coeff_modulus_128(2048))
+
+    # The plaintext modulus can be any positive integer, even though here we take
+    # it to be a power of two. In fact, in many cases one might instead want it to
+    # be a prime number; we will see this in example_batching(). The plaintext
+    # modulus determines the size of the plaintext data type, but it also affects
+    # the noise budget in a freshly encrypted ciphertext, and the consumption of
+    # the noise budget in homomorphic multiplication. Thus, it is essential to try
+    # to keep the plaintext data type as small as possible for good performance.
+    # The noise budget in a freshly encrypted ciphertext is
+
+    #     ~ log2(coeff_modulus/plain_modulus) (bits)
+
+    # and the noise budget consumption in a homomorphic multiplication is of the
+    # form log2(plain_modulus) + (other terms).
+    parms.set_plain_modulus(1 << 8)
+
+    # Now that all parameters are set, we are ready to construct a SEALContext
+    # object. This is a heavy class that checks the validity and properties of
+    # the parameters we just set, and performs and stores several important
+    # pre-computations.
+    context = SEALContext(parms)
+
+    # Print the parameters that we have chosen
+    print_parameters(context);
+
+ 
+    encoder = IntegerEncoder(context.plain_modulus())
+
+    # We are now ready to generate the secret and public keys. For this purpose we need
+    # an instance of the KeyGenerator class. Constructing a KeyGenerator automatically
+    # generates the public and secret key, which can then be read to local variables.
+    # To create a fresh pair of keys one can call KeyGenerator::generate() at any time.
+    keygen = KeyGenerator(context)
+    public_key = keygen.public_key()
+    secret_key = keygen.secret_key()
+
+    # To be able to encrypt, we need to construct an instance of Encryptor. Note that
+    # the Encryptor only requires the public key.
+    encryptor = Encryptor(context, public_key)
+
+    # Computations on the ciphertexts are performed with the Evaluator class.
+    evaluator = Evaluator(context)
+
+    # We will of course want to decrypt our results to verify that everything worked,
+    # so we need to also construct an instance of Decryptor. Note that the Decryptor
+    # requires the secret key.
+    decryptor = Decryptor(context, secret_key)
+
+    # We start by encoding two integers as plaintext polynomials.
+    value1 = 5;
+    plain1 = encoder.encode(value1);
+    print("Encoded " + (str)(value1) + " as polynomial " + plain1.to_string() + " (plain1)")
+
+    value2 = -7;
+    plain2 = encoder.encode(value2);
+    print("Encoded " + (str)(value2) + " as polynomial " + plain2.to_string() + " (plain2)")
+
+    # Encrypting the values is easy.
+    encrypted1 = Ciphertext()
+    encrypted2 = Ciphertext()
+    print("Encrypting plain1: ")
+    encryptor.encrypt(plain1, encrypted1)
+    print("Done (encrypted1)")
+
+    encrypted1.save()
+
+    print("Encrypting plain2: ")
+    encryptor.encrypt(plain2, encrypted2)
+    print("Done (encrypted2)")
+
+    # To illustrate the concept of noise budget, we print the budgets in the fresh
+    # encryptions.
+    print("Noise budget in encrypted1: " + (str)(decryptor.invariant_noise_budget(encrypted1)) + " bits")
+    print("Noise budget in encrypted2: " + (str)(decryptor.invariant_noise_budget(encrypted2)) + " bits")
+
+    # As a simple example, we compute (-encrypted1 + encrypted2) * encrypted2.
+
+    # Negation is a unary operation.
+    evaluator.negate(encrypted1)
+
+    # Negation does not consume any noise budget.
+    print("Noise budget in -encrypted1: " + (str)(decryptor.invariant_noise_budget(encrypted1)) + " bits")
+
+    # Addition can be done in-place (overwriting the first argument with the result,
+    # or alternatively a three-argument overload with a separate destination variable
+    # can be used. The in-place variants are always more efficient. Here we overwrite
+    # encrypted1 with the sum.
+    evaluator.add(encrypted1, encrypted2)
+
+    # It is instructive to think that addition sets the noise budget to the minimum
+    # of the input noise budgets. In this case both inputs had roughly the same
+    # budget going on, and the output (in encrypted1) has just slightly lower budget.
+    # Depending on probabilistic effects, the noise growth consumption may or may
+    # not be visible when measured in whole bits.
+    print("Noise budget in -encrypted1 + encrypted2: " + (str)(decryptor.invariant_noise_budget(encrypted1)) + " bits")
+
+    # Finally multiply with encrypted2. Again, we use the in-place version of the
+    # function, overwriting encrypted1 with the product.
+    evaluator.multiply(encrypted1, encrypted2)
+
+    # Multiplication consumes a lot of noise budget. This is clearly seen in the
+    # print-out. The user can change the plain_modulus to see its effect on the
+    # rate of noise budget consumption.
+    print("Noise budget in (-encrypted1 + encrypted2) * encrypted2: " + (str)(decryptor.invariant_noise_budget(encrypted1)) + " bits")
+
+    # Now we decrypt and decode our result.
+    plain_result = Plaintext()
+    print("Decrypting result: ")
+    decryptor.decrypt(encrypted1, plain_result)
+    print("Done")
+
+    # Print the result plaintext polynomial.
+    print("Plaintext polynomial: " + plain_result.to_string())
+
+    # Decode to obtain an integer result.
+    print("Decoded integer: " + (str)(encoder.decode_int32(plain_result)))
+
+
+
 def main():
-    # Example: Basics I
-    example_basics_i()
-    # Example: Basics II
-    example_basics_ii()
-    # Example: Weighted Average
-    example_weighted_average()
-    # Example: Batching using CRT
-    example_batching()
-    # Example: Parameter Selection
-    example_parameter_selection()
-    # Example: Performance (Single Thread)
-    example_performance_st()
-    # Example: Performance (Multi Thread)
-    th_count = ((int)(input('Thread count: ')))
-    if th_count > 0: example_performance_mt(th_count)
-    else: print('Invalid thread count.')
-    # Wait for ENTER before closing screen.
+    # # Example: Basics I
+    # example_basics_i()
+    # # Example: Basics II
+    # example_basics_ii()
+    # # Example: Weighted Average
+    # example_weighted_average()
+    # # Example: Batching using CRT
+    # example_batching()
+    # # Example: Parameter Selection
+    # example_parameter_selection()
+    # # Example: Performance (Single Thread)
+    # example_performance_st()
+    # # Example: Performance (Multi Thread)
+    # th_count = ((int)(input('Thread count: ')))
+    # if th_count > 0: example_performance_mt(th_count)
+    # else: print('Invalid thread count.')
+    # # Wait for ENTER before closing screen.
+
+    save_example()
     input('Press ENTER to exit')
 
 def print_example_banner(title, ch='*', length=78):

Diff for: SEALPythonExamples/examples.py

@@ -1,2 +1,2 @@
 #!/bin/bash
-docker build -t seal -f Dockerfile .
+docker build -t seal-save -f Dockerfile .

Diff for: build-docker.sh

@@ -1,4 +1,4 @@
 #!/bin/bash
 # docker run -it seal bash
 # docker run -it seal ./bin/sealexamples
-docker run -it seal python3 SEALPythonExamples/examples.py
+docker run -it seal-io python3 SEALPythonExamples/examples.py