deserialize bindings

src/bindings.cpp

@@ -48,12 +48,14 @@ void bind_crypto_context(py::module &m)
              "Encrypt a plaintext using public key")
         .def("EvalAdd", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(ConstCiphertext<DCRTPoly>, ConstCiphertext<DCRTPoly>) const>(&CryptoContextImpl<DCRTPoly>::EvalAdd), "Add two ciphertexts")
         .def("EvalMult", static_cast<Ciphertext<DCRTPoly> (CryptoContextImpl<DCRTPoly>::*)(ConstCiphertext<DCRTPoly>, ConstCiphertext<DCRTPoly>) const>(&CryptoContextImpl<DCRTPoly>::EvalMult), "Multiply two ciphertexts")
-        .def_static("ClearEvalMultKeys", [](){
-                CryptoContextImpl<DCRTPoly>::ClearEvalMultKeys();
-            }, "Clear the evaluation keys for multiplication")
-        .def_static("ClearEvalAutomorphismKeys", [](){
-                CryptoContextImpl<DCRTPoly>::ClearEvalAutomorphismKeys();
-            }, "Clear the evaluation keys for rotation")
+        .def_static(
+            "ClearEvalMultKeys", []()
+            { CryptoContextImpl<DCRTPoly>::ClearEvalMultKeys(); },
+            "Clear the evaluation keys for multiplication")
+        .def_static(
+            "ClearEvalAutomorphismKeys", []()
+            { CryptoContextImpl<DCRTPoly>::ClearEvalAutomorphismKeys(); },
+            "Clear the evaluation keys for rotation")
         .def_static(
             "SerializeEvalMultKey", [](const std::string &filename, const SerType::SERBINARY &sertype, std::string id = "")
             {
@@ -64,13 +66,33 @@ void bind_crypto_context(py::module &m)
                 return res; },
             py::arg("filename"), py::arg("sertype"), py::arg("id") = "",
             "Serialize an evaluation key for multiplication")
-            .def_static("SerializeEvalAutomorphismKey", [](const std::string &filename, const SerType::SERBINARY &sertype, std::string id = "")
+        .def_static(
+            "SerializeEvalAutomorphismKey", [](const std::string &filename, const SerType::SERBINARY &sertype, std::string id = "")
             {
                 std::ofstream outfile(filename,std::ios::out | std::ios::binary);
                 bool res;
                 res = CryptoContextImpl<DCRTPoly>::SerializeEvalAutomorphismKey<SerType::SERBINARY>(outfile, sertype, id);
                 outfile.close();
-                return res; },py::arg("filename"), py::arg("sertype"), py::arg("id") = "",  "Serialize evaluation keys for rotation");
+                return res; },
+            py::arg("filename"), py::arg("sertype"), py::arg("id") = "", "Serialize evaluation keys for rotation")
+        .def_static("DeserializeEvalMultKey", [](const std::string &filename, const SerType::SERBINARY &sertype)
+                    {
+                        std::ifstream emkeys(filename, std::ios::in | std::ios::binary);
+                         if (!emkeys.is_open()) {
+                            std::cerr << "I cannot read serialization from " << filename << std::endl;
+                         }
+                        bool res;
+                        res = CryptoContextImpl<DCRTPoly>::DeserializeEvalMultKey<SerType::SERBINARY>(emkeys, sertype);
+                        return res; })
+        .def_static("DeserializeEvalAutomorphismKey", [](const std::string &filename, const SerType::SERBINARY &sertype)
+                    {
+                        std::ifstream erkeys(filename, std::ios::in | std::ios::binary);
+                         if (!erkeys.is_open()) {
+                            std::cerr << "I cannot read serialization from " << filename << std::endl;
+                         }
+                        bool res;
+                        res = CryptoContextImpl<DCRTPoly>::DeserializeEvalAutomorphismKey<SerType::SERBINARY>(erkeys, sertype);
+                        return res; });
 
     // Generator Functions
     m.def("GenCryptoContext", &GenCryptoContext<CryptoContextBFVRNS>);

src/pke/examples/simple-integers-serial.py

@@ -113,6 +113,55 @@ pk = PublicKey()
 if not DeserializeFromFile(datafolder + "/key-public.txt", pk, BINARY):
    raise Exception("Error reading serialization of the public key from key-public.txt")
 
+print("The public key has been deserialized.")
+
+# if cryptoContext.DeserializeEvalMultKey(datafolder + "/key-relin.txt",BINARY):
+#    raise Exception("Could not deserialize the eval mult key file")
+
+# print("The relinearization key has been deserialized.")
+
+# if cryptoContext.DeserializeEvalAutomorphismKey(datafolder + "/key-eval-rot.txt",BINARY):
+#    raise Exception("Could not deserialize the eval rotation key file")
+
+# print("Deserialized the eval rotation keys.")
+
+# Deserialize the ciphertexts
+
+ct1 = Ciphertext()
+ct2 = Ciphertext()
+ct3 = Ciphertext()
+
+if not DeserializeFromFile(datafolder + "/ciphertext1.txt", ct1, BINARY):
+    raise Exception("Could not read the ciphertext")
+
+print("The first ciphertext has been deserialized.")
+
+if not DeserializeFromFile(datafolder + "/ciphertext2.txt", ct2, BINARY):
+    raise Exception("Could not read the ciphertext")
+
+print("The second ciphertext has been deserialized.")
+
+if not DeserializeFromFile(datafolder + "/ciphertext3.txt", ct3, BINARY):   
+    raise Exception("Could not read the ciphertext")
+
+print("The third ciphertext has been deserialized.")
+
+# Homomorphic addition
+
+ciphertextAdd12 = cc.EvalAdd(ct1, ct2)
+ciphertextAddResult = cc.EvalAdd(ciphertextAdd12, ct3)
+
+# Homomorphic multiplication
+ciphertextMult12 = cc.EvalMult(ct1, ct2)
+ciphertextMultResult = cc.EvalMult(ciphertextMult12, ct3)
+
+# Homomorphic rotation
+ciphertextRot1 = cc.EvalRotate(ct1, 1)
+ciphertextRot2 = cc.EvalRotate(ct2, 2)
+ciphertextRot3 = cc.EvalRotate(ct3, -1)
+ciphertextRot4 = cc.EvalRotate(ct3, -2)
+
+
 
 
 

src/pke/serialization.cpp

@@ -26,14 +26,18 @@ void bind_serialization(pybind11::module &m) {
     m.def("SerializeToFile", static_cast<bool (*)(const std::string&, const PublicKey<DCRTPoly>&, const SerType::SERJSON&)>(&Serial::SerializeToFile<PublicKey<DCRTPoly>>), py::arg("filename"), py::arg("obj"), py::arg("sertype"));
     m.def("DeserializeFromFile", static_cast<bool (*)(const std::string&, PublicKey<DCRTPoly>& ,const SerType::SERJSON&)>(&Serial::DeserializeFromFile<PublicKey<DCRTPoly>>), py::arg("filename"), py::arg("obj"), py::arg("sertype"));
     m.def("SerializeToFile", static_cast<bool (*)(const std::string&, const PrivateKey<DCRTPoly>&, const SerType::SERJSON&)>(&Serial::SerializeToFile<PrivateKey<DCRTPoly>>), py::arg("filename"), py::arg("obj"), py::arg("sertype"));
+    m.def("DeserializeFromFile", static_cast<bool (*)(const std::string&, PrivateKey<DCRTPoly>& ,const SerType::SERJSON&)>(&Serial::DeserializeFromFile<PrivateKey<DCRTPoly>>), py::arg("filename"), py::arg("obj"), py::arg("sertype"));
     m.def("SerializeToFile", static_cast<bool (*)(const std::string&, const Ciphertext<DCRTPoly>&, const SerType::SERJSON&)>(&Serial::SerializeToFile<Ciphertext<DCRTPoly>>), py::arg("filename"), py::arg("obj"), py::arg("sertype"));
+    m.def("DeserializeFromFile", static_cast<bool (*)(const std::string&, Ciphertext<DCRTPoly>& ,const SerType::SERJSON&)>(&Serial::DeserializeFromFile<Ciphertext<DCRTPoly>>), py::arg("filename"), py::arg("obj"), py::arg("sertype"));
     // Binary Serialization
     m.def("SerializeToFile", static_cast<bool (*)(const std::string&, const CryptoContext<DCRTPoly>&, const SerType::SERBINARY&)>(&Serial::SerializeToFile<DCRTPoly>), py::arg("filename"), py::arg("obj"), py::arg("sertype"));
     m.def("DeserializeFromFile", static_cast<bool (*)(const std::string&, CryptoContext<DCRTPoly>& ,const SerType::SERBINARY&)>(&Serial::DeserializeFromFile<DCRTPoly>), py::arg("filename"), py::arg("obj"), py::arg("sertype"));
     m.def("SerializeToFile", static_cast<bool (*)(const std::string&, const PublicKey<DCRTPoly>&, const SerType::SERBINARY&)>(&Serial::SerializeToFile<PublicKey<DCRTPoly>>), py::arg("filename"), py::arg("obj"), py::arg("sertype"));
     m.def("DeserializeFromFile", static_cast<bool (*)(const std::string&, PublicKey<DCRTPoly>& ,const SerType::SERBINARY&)>(&Serial::DeserializeFromFile<PublicKey<DCRTPoly>>), py::arg("filename"), py::arg("obj"), py::arg("sertype"));
     m.def("SerializeToFile", static_cast<bool (*)(const std::string&, const PrivateKey<DCRTPoly>&, const SerType::SERBINARY&)>(&Serial::SerializeToFile<PrivateKey<DCRTPoly>>), py::arg("filename"), py::arg("obj"), py::arg("sertype"));
+    m.def("DeserializeFromFile", static_cast<bool (*)(const std::string&, PrivateKey<DCRTPoly>& ,const SerType::SERBINARY&)>(&Serial::DeserializeFromFile<PrivateKey<DCRTPoly>>), py::arg("filename"), py::arg("obj"), py::arg("sertype"));
     m.def("SerializeToFile", static_cast<bool (*)(const std::string&, const Ciphertext<DCRTPoly>&, const SerType::SERBINARY&)>(&Serial::SerializeToFile<Ciphertext<DCRTPoly>>), py::arg("filename"), py::arg("obj"), py::arg("sertype"));
+    m.def("DeserializeFromFile", static_cast<bool (*)(const std::string&, Ciphertext<DCRTPoly>& ,const SerType::SERBINARY&)>(&Serial::DeserializeFromFile<Ciphertext<DCRTPoly>>), py::arg("filename"), py::arg("obj"), py::arg("sertype"));
     
     
 }