port BugUInt, ChooserEvaluator, and EncryptionParams to python

Author: Todd Stavish

README.md

@@ -1,5 +1,3 @@
-This is an unofficial fork of the Microsoft SEAL homomorphic encryption library demonstrating a python wrapper proof of concept that is dockerized
+This repository is a proof of concept for adding a Python wrapper to the (Simple Encrypted Arithmetic Library (SEAL))[https://sealcrypto.org/], a homomorphic encryption library, developed by researchers in the Cryptography Research Group at Microsoft Research. Currently, this uses the version 2.2 codebase and dockerizes the library build (including a shared runtime), C++ example build, and Python wrapper build. The Python wrapper is using pybind11.
 
 Original home: https://www.microsoft.com/en-us/research/project/simple-encrypted-arithmetic-library-seal-2/
-
-This repository is a proof of concept for adding a Python wrapper to the (Simple Encrypted Arithmetic Library (SEAL))[https://sealcrypto.org/], a homomorphic encryption library, developed by researchers in the Cryptography Research Group at Microsoft Research. Currently, this uses the version 2.2 codebase and dockerizes the library build (including a shared runtime), C++ example build, and Python wrapper build. The Python wrapper is using pybind11.

SEALPython/SEALWrapper.cpp

@@ -8,7 +8,7 @@
 ext_modules = [
     Extension(
         'seal',
-        ['SEALWrapper.cpp'],
+        ['wrapper.cpp'],
         include_dirs=['/usr/include/python3.5', 'pybind11/include', '/SEAL/SEAL'],
         language='c++',
         extra_compile_args = cpp_args,

SEALPython/setup.py

@@ -0,0 +1,41 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include "biguint.h"
+#include "chooser.h"
+#include "encryptionparams.h"
+
+namespace py = pybind11;
+
+using namespace pybind11::literals;
+using namespace seal;
+using namespace std;
+
+// http://pybind11.readthedocs.io/en/stable/classes.html
+
+PYBIND11_MODULE(seal, m) {
+
+  py::class_<BigUInt>(m, "BigUInt")
+    .def(py::init<>())
+    .def("to_double", &BigUInt::to_double,
+          "Returns the BigUInt value as a double. Note that precision may be lost during the conversion.");
+
+  py::class_<ChooserEvaluator>(m, "ChooserEvaluator")
+    .def_static("default_parameter_options", &ChooserEvaluator::default_parameter_options,
+               "Retrieve default parameter options");
+
+  py::class_<EncryptionParameters>(m, "EncryptionParameters")
+    .def(py::init<>())
+    .def(py::init<const MemoryPoolHandle &>())
+    .def("set_coeff_modulus",
+        (void (EncryptionParameters::*)(const BigUInt &)) &EncryptionParameters::set_coeff_modulus,
+        "Set coefficient modulus parameter")
+    .def("set_coeff_modulus",
+        (void (EncryptionParameters::*)(std::uint64_t)) &EncryptionParameters::set_coeff_modulus,
+        "Set coefficient modulus parameter")
+    .def("set_coeff_modulus",
+        (void (EncryptionParameters::*)(const std::string &)) &EncryptionParameters::set_coeff_modulus,
+        "Set coefficient modulus parameter")
+    .def("set_poly_modulus",
+        (void (EncryptionParameters::*)(const std::string &)) &EncryptionParameters::set_poly_modulus,
+        "Set polynomial modulus parameter");
+}

SEALPython/wrapper.cpp

@@ -1,4 +1,4 @@
-from seal import EncryptionParameters
+from seal import EncryptionParameters, ChooserEvaluator
 
 def example_basics():
     """
@@ -19,6 +19,51 @@ def example_basics():
     # We recommend using polynomials of degree at least 1024.
     parms.set_poly_modulus('1x^2048 + 1')
 
+    # Next we choose the coefficient modulus. SEAL comes with default values for
+    # the coefficient modulus for some of the most reasonable choices of
+    # poly_modulus. They are as follows:
+    #
+    # /----------------------------------------------------------------------\
+    # | poly_modulus | default coeff_modulus                      | security |
+    # | -------------|--------------------------------------------|----------|
+    # | 1x^2048 + 1  | 2^60 - 2^14 + 1 (60 bits)                  | 119 bit  |
+    # | 1x^4096 + 1  | 2^116 - 2^18 + 1 (116 bits)                | 122 bit  |
+    # | 1x^8192 + 1  | 2^226 - 2^26 + 1 (226 bits)                | 124 bit  |
+    # | 1x^16384 + 1 | 2^435 - 2^33 + 1 (435 bits)                | 130 bit  |
+    # | 1x^32768 + 1 | 2^889 - 2^54 - 2^53 - 2^52 + 1 (889 bits)  | 127 bit  |
+    # \----------------------------------------------------------------------/
+    #
+    # These can be conveniently accessed using
+    # ChooserEvaluator::default_parameter_options(), which returns the above
+    # list of options as an std::map, keyed by the degree of the polynomial
+    # modulus. The security levels are estimated based on
+    # https://eprint.iacr.org/2015/046 and https://eprint.iacr.org/2017/047. We
+    # strongly recommend that the user consult an expert in the security of
+    # RLWE-based cryptography to estimate the security of a particular choice
+    # of parameters.
+    #
+    # The user can also easily choose their custom coefficient modulus. For best
+    # performance, it should  be a prime of the form 2^A - B, where B is
+    # congruent to 1 modulo 2*degree(poly_modulus), and as small as possible.
+    # Roughly speaking, When the rest of the parameters are held fixed,
+    # increasing coeff_modulus decreases the security level. Thus we would not
+    # recommend using a value for coeff_modulus much larger than those listed
+    # above (the defaults). In general, we highly recommend the user to consult
+    # with an expert in the security of RLWE-based cryptography when selecting
+    # their parameters to ensure an appropriate level of security.
+    #
+    # The size of coeff_modulus affects the total noise budget that a freshly
+    # encrypted ciphertext has. More precisely, every ciphertext starts with a
+    # certain amount of noise budget, which is consumed in homomorphic
+    # operations - in particular in multiplication. Once the noise budget
+    # reaches 0, the ciphertext becomes impossible to decrypt. The total noise
+    # budget in a freshly encrypted ciphertext is very roughly given by
+    # log2(coeff_modulus/plain_modulus), so increasing coeff_modulus will allow
+    # the user to perform more homomorphic operations on the ciphertexts without
+    #  corrupting them. However, we must again warn that increasing
+    # coeff_modulus has a strong negative effect on the security level.
+    parms.set_coeff_modulus(ChooserEvaluator.default_parameter_options()[2048]);
+
 def main():
     # Example: Basics
     example_basics()