From 0389381b7e82459765be5ded5aae9196dd353a13 Mon Sep 17 00:00:00 2001 From: Muthu Annamalai Date: Mon, 23 Sep 2024 08:38:06 -0700 Subject: [PATCH 1/2] - checkpt --- src/include/docstrings/binfhecontext_docs.h | 14 +++++++++ src/lib/binfhe_bindings.cpp | 32 ++++++++++++++++++++- 2 files changed, 45 insertions(+), 1 deletion(-) diff --git a/src/include/docstrings/binfhecontext_docs.h b/src/include/docstrings/binfhecontext_docs.h index 62776c8..a648575 100644 --- a/src/include/docstrings/binfhecontext_docs.h +++ b/src/include/docstrings/binfhecontext_docs.h @@ -185,4 +185,18 @@ const char* binfhe_EvalSign_docs = R"pbdoc( :return: the resulting ciphertext :rtype: LWECiphertext )pbdoc"; + +const char* binfhe_SerializedVersion_docs = R"pbdoc( + Return the serialized version number in use. + + :return: the version number + :rtype: uint32_t +)pbdoc"; + +const char* binfhe_SerializedObjectName_docs = R"pbdoc( + Return the serialized object name + + :return: object name + :rtype: std::string +)pbdoc"; #endif // BINFHECONTEXT_DOCSTRINGS_H diff --git a/src/lib/binfhe_bindings.cpp b/src/lib/binfhe_bindings.cpp index f743673..191f4d8 100644 --- a/src/lib/binfhe_bindings.cpp +++ b/src/lib/binfhe_bindings.cpp @@ -33,6 +33,9 @@ #include "binfhecontext.h" #include "binfhecontext_wrapper.h" #include "binfhecontext_docs.h" +#include "openfhe/core/utils/serial.h" +#include "openfhe/cereal/archives/binary.hpp" +#include "openfhe/cereal/archives/portable_binary.hpp" using namespace lbcrypto; namespace py = pybind11; @@ -170,6 +173,8 @@ void bind_binfhe_context(py::module &m) py::arg("timeOptimization") = false) .def("KeyGen", &BinFHEContext::KeyGen, binfhe_KeyGen_docs) + .def("KeyGenN", &BinFHEContext::KeyGenN) + .def("KeyGenPair", &BinFHEContext::KeyGenPair) .def("BTKeyGen", &BinFHEContext::BTKeyGen, binfhe_BTKeyGen_docs, py::arg("sk"), @@ -192,6 +197,11 @@ void bind_binfhe_context(py::module &m) py::arg("gate"), py::arg("ct1"), py::arg("ct2")) + .def("EvalBinGate", + static_cast &) const>(&BinFHEContext::EvalBinGate), + py::arg("gate"), + py::arg("ctvector") + ) .def("EvalNOT", &BinFHEContext::EvalNOT, binfhe_EvalNOT_docs, py::arg("ct")) @@ -217,5 +227,25 @@ void bind_binfhe_context(py::module &m) .def("EvalSign",&BinFHEContext::EvalSign, binfhe_EvalSign_docs, py::arg("ct"), - py::arg("schemeSwitch") = false); + py::arg("schemeSwitch") = false) + .def("EvalNOT",&BinFHEContext::EvalNOT) + .def("EvalConstant",&BinFHEContext::EvalConstant) + .def("ClearBTKeys",&BinFHEContext::ClearBTKeys) + .def("Bootstrap",&BinFHEContext::Bootstrap,py::arg("ct")) + .def("SerializedVersion",&BinFHEContext::SerializedVersion, + binfhe_SerializedVersion_docs) + .def("SerializedObjectName",&BinFHEContext::SerializedObjectName, + binfhe_SerializedObjectName_docs) + .def("SaveJSON",&BinFHEContext::save) + .def("LoadJSON",&BinFHEContext::load) + .def("SaveBinary",&BinFHEContext::save) + .def("LoadBinary",&BinFHEContext::load) + .def("SavePortableBinary",&BinFHEContext::save) + .def("LoadPortableBinary",&BinFHEContext::load) + .def("GetPublicKey",&BinFHEContext::GetPublicKey) + .def("GetSwitchKey",&BinFHEContext::GetSwitchKey) + .def("GetRefreshKey",&BinFHEContext::GetRefreshKey) + .def("GetBinFHEScheme",&BinFHEContext::GetBinFHEScheme) + .def("GetLWEScheme",&BinFHEContext::GetLWEScheme) + .def("GetParams",&BinFHEContext::GetParams); } From 615f02d40147126d602f57ccd9581a5f34b7102d Mon Sep 17 00:00:00 2001 From: Muthu Annamalai Date: Mon, 23 Sep 2024 08:45:48 -0700 Subject: [PATCH 2/2] - checkpt2 --- src/lib/binfhe_bindings.cpp | 419 +++++++++++++++++------------------- 1 file changed, 201 insertions(+), 218 deletions(-) diff --git a/src/lib/binfhe_bindings.cpp b/src/lib/binfhe_bindings.cpp index 191f4d8..78651b7 100644 --- a/src/lib/binfhe_bindings.cpp +++ b/src/lib/binfhe_bindings.cpp @@ -7,7 +7,8 @@ // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: -// 1. Redistributions of source code must retain the above copyright notice, this +// 1. Redistributions of source code must retain the above copyright notice, +// this // list of conditions and the following disclaimer. // 2. Redistributions in binary form must reproduce the above copyright notice, @@ -16,236 +17,218 @@ // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE -// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. -#include -#include -#include -#include "openfhe.h" #include "binfhe_bindings.h" #include "binfhecontext.h" -#include "binfhecontext_wrapper.h" #include "binfhecontext_docs.h" -#include "openfhe/core/utils/serial.h" +#include "binfhecontext_wrapper.h" +#include "openfhe.h" #include "openfhe/cereal/archives/binary.hpp" #include "openfhe/cereal/archives/portable_binary.hpp" +#include "openfhe/core/utils/serial.h" +#include +#include +#include using namespace lbcrypto; namespace py = pybind11; -void bind_binfhe_enums(py::module &m) -{ - py::enum_(m, "BINFHE_PARAMSET") - .value("TOY", BINFHE_PARAMSET::TOY) - .value("MEDIUM", BINFHE_PARAMSET::MEDIUM) - .value("STD128_LMKCDEY", BINFHE_PARAMSET::STD128_LMKCDEY) - .value("STD128_AP", BINFHE_PARAMSET::STD128_AP) - .value("STD128", BINFHE_PARAMSET::STD128) - .value("STD192", BINFHE_PARAMSET::STD192) - .value("STD256", BINFHE_PARAMSET::STD256) - .value("STD128Q", BINFHE_PARAMSET::STD128Q) - .value("STD128Q_LMKCDEY", BINFHE_PARAMSET::STD128Q_LMKCDEY) - .value("STD192Q", BINFHE_PARAMSET::STD192Q) - .value("STD256Q", BINFHE_PARAMSET::STD256Q) - .value("STD128_3", BINFHE_PARAMSET::STD128_3) - .value("STD128_3_LMKCDEY", BINFHE_PARAMSET::STD128_3_LMKCDEY) - .value("STD128Q_3", BINFHE_PARAMSET::STD128Q_3) - .value("STD128Q_3_LMKCDEY", BINFHE_PARAMSET::STD128Q_3_LMKCDEY) - .value("STD192Q_3", BINFHE_PARAMSET::STD192Q_3) - .value("STD256Q_3", BINFHE_PARAMSET::STD256Q_3) - .value("STD128_4", BINFHE_PARAMSET::STD128_4) - .value("STD128_4_LMKCDEY", BINFHE_PARAMSET::STD128_4_LMKCDEY) - .value("STD128Q_4", BINFHE_PARAMSET::STD128Q_4) - .value("STD128Q_4_LMKCDEY", BINFHE_PARAMSET::STD128Q_4_LMKCDEY) - .value("STD192Q_4", BINFHE_PARAMSET::STD192Q_4) - .value("STD256Q_4", BINFHE_PARAMSET::STD256Q_4) - .value("SIGNED_MOD_TEST", BINFHE_PARAMSET::SIGNED_MOD_TEST); - m.attr("TOY") = py::cast(BINFHE_PARAMSET::TOY); - m.attr("MEDIUM") = py::cast(BINFHE_PARAMSET::MEDIUM); - m.attr("STD128_LMKCDEY") = py::cast(BINFHE_PARAMSET::STD128_LMKCDEY); - m.attr("STD128_AP") = py::cast(BINFHE_PARAMSET::STD128_AP); - m.attr("STD128") = py::cast(BINFHE_PARAMSET::STD128); - m.attr("STD192") = py::cast(BINFHE_PARAMSET::STD192); - m.attr("STD256") = py::cast(BINFHE_PARAMSET::STD256); - m.attr("STD128Q") = py::cast(BINFHE_PARAMSET::STD128Q); - m.attr("STD128Q_LMKCDEY") = py::cast(BINFHE_PARAMSET::STD128Q_LMKCDEY); - m.attr("STD192Q") = py::cast(BINFHE_PARAMSET::STD192Q); - m.attr("STD256Q") = py::cast(BINFHE_PARAMSET::STD256Q); - m.attr("STD128_3") = py::cast(BINFHE_PARAMSET::STD128_3); - m.attr("STD128_3_LMKCDEY") = py::cast(BINFHE_PARAMSET::STD128_3_LMKCDEY); - m.attr("STD128Q_3") = py::cast(BINFHE_PARAMSET::STD128Q_3); - m.attr("STD128Q_3_LMKCDEY") = py::cast(BINFHE_PARAMSET::STD128Q_3_LMKCDEY); - m.attr("STD192Q_3") = py::cast(BINFHE_PARAMSET::STD192Q_3); - m.attr("STD256Q_3") = py::cast(BINFHE_PARAMSET::STD256Q_3); - m.attr("STD128_4") = py::cast(BINFHE_PARAMSET::STD128_4); - m.attr("STD128_4_LMKCDEY") = py::cast(BINFHE_PARAMSET::STD128_4_LMKCDEY); - m.attr("STD128Q_4") = py::cast(BINFHE_PARAMSET::STD128Q_4); - m.attr("STD128Q_4_LMKCDEY") = py::cast(BINFHE_PARAMSET::STD128Q_4_LMKCDEY); - m.attr("STD192Q_4") = py::cast(BINFHE_PARAMSET::STD192Q_4); - m.attr("STD256Q_4") = py::cast(BINFHE_PARAMSET::STD256Q_4); - m.attr("SIGNED_MOD_TEST") = py::cast(BINFHE_PARAMSET::SIGNED_MOD_TEST); - - py::enum_(m, "BINFHE_METHOD") - .value("INVALID_METHOD", BINFHE_METHOD::INVALID_METHOD) - .value("AP", BINFHE_METHOD::AP) - .value("GINX", BINFHE_METHOD::GINX) - .value("LMKCDEY", BINFHE_METHOD::LMKCDEY); - m.attr("INVALID_METHOD") = py::cast(BINFHE_METHOD::INVALID_METHOD); - m.attr("GINX") = py::cast(BINFHE_METHOD::GINX); - m.attr("AP") = py::cast(BINFHE_METHOD::AP); - m.attr("LMKCDEY") = py::cast(BINFHE_METHOD::LMKCDEY); - - py::enum_(m, "KEYGEN_MODE") - .value("SYM_ENCRYPT", KEYGEN_MODE::SYM_ENCRYPT) - .value("PUB_ENCRYPT", KEYGEN_MODE::PUB_ENCRYPT); - m.attr("SYM_ENCRYPT") = py::cast(KEYGEN_MODE::SYM_ENCRYPT); - m.attr("PUB_ENCRYPT") = py::cast(KEYGEN_MODE::PUB_ENCRYPT); - - py::enum_(m, "BINFHE_OUTPUT") - .value("INVALID_OUTPUT", BINFHE_OUTPUT::INVALID_OUTPUT) - .value("FRESH", BINFHE_OUTPUT::FRESH) - .value("BOOTSTRAPPED", BINFHE_OUTPUT::BOOTSTRAPPED); - m.attr("INVALID_OUTPUT") = py::cast(BINFHE_OUTPUT::INVALID_OUTPUT); - m.attr("FRESH") = py::cast(BINFHE_OUTPUT::FRESH); - m.attr("BOOTSTRAPPED") = py::cast(BINFHE_OUTPUT::BOOTSTRAPPED); - - py::enum_(m, "BINGATE") - .value("OR", BINGATE::OR) - .value("AND", BINGATE::AND) - .value("NOR", BINGATE::NOR) - .value("NAND", BINGATE::NAND) - .value("XOR_FAST", BINGATE::XOR_FAST) - .value("XNOR_FAST", BINGATE::XNOR_FAST) - .value("XOR", BINGATE::XOR) - .value("XNOR", BINGATE::XNOR); - m.attr("OR") = py::cast(BINGATE::OR); - m.attr("AND") = py::cast(BINGATE::AND); - m.attr("NOR") = py::cast(BINGATE::NOR); - m.attr("NAND") = py::cast(BINGATE::NAND); - m.attr("XOR_FAST") = py::cast(BINGATE::XOR_FAST); - m.attr("XNOR_FAST") = py::cast(BINGATE::XNOR_FAST); - m.attr("XOR") = py::cast(BINGATE::XOR); - m.attr("XNOR") = py::cast(BINGATE::XNOR); - +void bind_binfhe_enums(py::module &m) { + py::enum_(m, "BINFHE_PARAMSET") + .value("TOY", BINFHE_PARAMSET::TOY) + .value("MEDIUM", BINFHE_PARAMSET::MEDIUM) + .value("STD128_LMKCDEY", BINFHE_PARAMSET::STD128_LMKCDEY) + .value("STD128_AP", BINFHE_PARAMSET::STD128_AP) + .value("STD128", BINFHE_PARAMSET::STD128) + .value("STD192", BINFHE_PARAMSET::STD192) + .value("STD256", BINFHE_PARAMSET::STD256) + .value("STD128Q", BINFHE_PARAMSET::STD128Q) + .value("STD128Q_LMKCDEY", BINFHE_PARAMSET::STD128Q_LMKCDEY) + .value("STD192Q", BINFHE_PARAMSET::STD192Q) + .value("STD256Q", BINFHE_PARAMSET::STD256Q) + .value("STD128_3", BINFHE_PARAMSET::STD128_3) + .value("STD128_3_LMKCDEY", BINFHE_PARAMSET::STD128_3_LMKCDEY) + .value("STD128Q_3", BINFHE_PARAMSET::STD128Q_3) + .value("STD128Q_3_LMKCDEY", BINFHE_PARAMSET::STD128Q_3_LMKCDEY) + .value("STD192Q_3", BINFHE_PARAMSET::STD192Q_3) + .value("STD256Q_3", BINFHE_PARAMSET::STD256Q_3) + .value("STD128_4", BINFHE_PARAMSET::STD128_4) + .value("STD128_4_LMKCDEY", BINFHE_PARAMSET::STD128_4_LMKCDEY) + .value("STD128Q_4", BINFHE_PARAMSET::STD128Q_4) + .value("STD128Q_4_LMKCDEY", BINFHE_PARAMSET::STD128Q_4_LMKCDEY) + .value("STD192Q_4", BINFHE_PARAMSET::STD192Q_4) + .value("STD256Q_4", BINFHE_PARAMSET::STD256Q_4) + .value("SIGNED_MOD_TEST", BINFHE_PARAMSET::SIGNED_MOD_TEST); + m.attr("TOY") = py::cast(BINFHE_PARAMSET::TOY); + m.attr("MEDIUM") = py::cast(BINFHE_PARAMSET::MEDIUM); + m.attr("STD128_LMKCDEY") = py::cast(BINFHE_PARAMSET::STD128_LMKCDEY); + m.attr("STD128_AP") = py::cast(BINFHE_PARAMSET::STD128_AP); + m.attr("STD128") = py::cast(BINFHE_PARAMSET::STD128); + m.attr("STD192") = py::cast(BINFHE_PARAMSET::STD192); + m.attr("STD256") = py::cast(BINFHE_PARAMSET::STD256); + m.attr("STD128Q") = py::cast(BINFHE_PARAMSET::STD128Q); + m.attr("STD128Q_LMKCDEY") = py::cast(BINFHE_PARAMSET::STD128Q_LMKCDEY); + m.attr("STD192Q") = py::cast(BINFHE_PARAMSET::STD192Q); + m.attr("STD256Q") = py::cast(BINFHE_PARAMSET::STD256Q); + m.attr("STD128_3") = py::cast(BINFHE_PARAMSET::STD128_3); + m.attr("STD128_3_LMKCDEY") = py::cast(BINFHE_PARAMSET::STD128_3_LMKCDEY); + m.attr("STD128Q_3") = py::cast(BINFHE_PARAMSET::STD128Q_3); + m.attr("STD128Q_3_LMKCDEY") = py::cast(BINFHE_PARAMSET::STD128Q_3_LMKCDEY); + m.attr("STD192Q_3") = py::cast(BINFHE_PARAMSET::STD192Q_3); + m.attr("STD256Q_3") = py::cast(BINFHE_PARAMSET::STD256Q_3); + m.attr("STD128_4") = py::cast(BINFHE_PARAMSET::STD128_4); + m.attr("STD128_4_LMKCDEY") = py::cast(BINFHE_PARAMSET::STD128_4_LMKCDEY); + m.attr("STD128Q_4") = py::cast(BINFHE_PARAMSET::STD128Q_4); + m.attr("STD128Q_4_LMKCDEY") = py::cast(BINFHE_PARAMSET::STD128Q_4_LMKCDEY); + m.attr("STD192Q_4") = py::cast(BINFHE_PARAMSET::STD192Q_4); + m.attr("STD256Q_4") = py::cast(BINFHE_PARAMSET::STD256Q_4); + m.attr("SIGNED_MOD_TEST") = py::cast(BINFHE_PARAMSET::SIGNED_MOD_TEST); + + py::enum_(m, "BINFHE_METHOD") + .value("INVALID_METHOD", BINFHE_METHOD::INVALID_METHOD) + .value("AP", BINFHE_METHOD::AP) + .value("GINX", BINFHE_METHOD::GINX) + .value("LMKCDEY", BINFHE_METHOD::LMKCDEY); + m.attr("INVALID_METHOD") = py::cast(BINFHE_METHOD::INVALID_METHOD); + m.attr("GINX") = py::cast(BINFHE_METHOD::GINX); + m.attr("AP") = py::cast(BINFHE_METHOD::AP); + m.attr("LMKCDEY") = py::cast(BINFHE_METHOD::LMKCDEY); + + py::enum_(m, "KEYGEN_MODE") + .value("SYM_ENCRYPT", KEYGEN_MODE::SYM_ENCRYPT) + .value("PUB_ENCRYPT", KEYGEN_MODE::PUB_ENCRYPT); + m.attr("SYM_ENCRYPT") = py::cast(KEYGEN_MODE::SYM_ENCRYPT); + m.attr("PUB_ENCRYPT") = py::cast(KEYGEN_MODE::PUB_ENCRYPT); + + py::enum_(m, "BINFHE_OUTPUT") + .value("INVALID_OUTPUT", BINFHE_OUTPUT::INVALID_OUTPUT) + .value("FRESH", BINFHE_OUTPUT::FRESH) + .value("BOOTSTRAPPED", BINFHE_OUTPUT::BOOTSTRAPPED); + m.attr("INVALID_OUTPUT") = py::cast(BINFHE_OUTPUT::INVALID_OUTPUT); + m.attr("FRESH") = py::cast(BINFHE_OUTPUT::FRESH); + m.attr("BOOTSTRAPPED") = py::cast(BINFHE_OUTPUT::BOOTSTRAPPED); + + py::enum_(m, "BINGATE") + .value("OR", BINGATE::OR) + .value("AND", BINGATE::AND) + .value("NOR", BINGATE::NOR) + .value("NAND", BINGATE::NAND) + .value("XOR_FAST", BINGATE::XOR_FAST) + .value("XNOR_FAST", BINGATE::XNOR_FAST) + .value("XOR", BINGATE::XOR) + .value("XNOR", BINGATE::XNOR); + m.attr("OR") = py::cast(BINGATE::OR); + m.attr("AND") = py::cast(BINGATE::AND); + m.attr("NOR") = py::cast(BINGATE::NOR); + m.attr("NAND") = py::cast(BINGATE::NAND); + m.attr("XOR_FAST") = py::cast(BINGATE::XOR_FAST); + m.attr("XNOR_FAST") = py::cast(BINGATE::XNOR_FAST); + m.attr("XOR") = py::cast(BINGATE::XOR); + m.attr("XNOR") = py::cast(BINGATE::XNOR); } -void bind_binfhe_keys(py::module &m) -{ - py::class_>(m, "LWEPrivateKey") - .def(py::init<>()) - .def("GetLength", &LWEPrivateKeyImpl::GetLength) - .def(py::self == py::self) - .def(py::self != py::self); +void bind_binfhe_keys(py::module &m) { + py::class_>( + m, "LWEPrivateKey") + .def(py::init<>()) + .def("GetLength", &LWEPrivateKeyImpl::GetLength) + .def(py::self == py::self) + .def(py::self != py::self); } -void bind_binfhe_ciphertext(py::module &m) -{ - py::class_>(m, "LWECiphertext") - .def(py::init<>()) - .def("GetLength", &LWECiphertextImpl::GetLength) - .def("GetModulus", &GetLWECiphertextModulusWrapper) - .def(py::self == py::self) - .def(py::self != py::self); +void bind_binfhe_ciphertext(py::module &m) { + py::class_>( + m, "LWECiphertext") + .def(py::init<>()) + .def("GetLength", &LWECiphertextImpl::GetLength) + .def("GetModulus", &GetLWECiphertextModulusWrapper) + .def(py::self == py::self) + .def(py::self != py::self); } -void bind_binfhe_context(py::module &m) -{ - py::class_>(m, "BinFHEContext") - .def(py::init<>()) - .def("GenerateBinFHEContext", static_cast(&BinFHEContext::GenerateBinFHEContext), - binfhe_GenerateBinFHEContext_parset_docs, - py::arg("set"), - py::arg("method") = GINX) - //void GenerateBinFHEContext(BINFHE_PARAMSET set, bool arbFunc, uint32_t logQ = 11, int64_t N = 0, BINFHE_METHOD method = GINX, bool timeOptimization = false) - .def("GenerateBinFHEContext", static_cast(&BinFHEContext::GenerateBinFHEContext), - binfhe_GenerateBinFHEContext_docs, - py::arg("set"), - py::arg("arbFunc"), - py::arg("logQ") = 11, - py::arg("N") = 0, - py::arg("method") = GINX, - py::arg("timeOptimization") = false) - .def("KeyGen", &BinFHEContext::KeyGen, - binfhe_KeyGen_docs) - .def("KeyGenN", &BinFHEContext::KeyGenN) - .def("KeyGenPair", &BinFHEContext::KeyGenPair) - .def("BTKeyGen", &BinFHEContext::BTKeyGen, - binfhe_BTKeyGen_docs, - py::arg("sk"), - py::arg("keygenMode") = SYM_ENCRYPT) - .def("Encrypt", &binfhe_EncryptWrapper, - binfhe_Encrypt_docs, - py::arg("sk"), - py::arg("m"), - py::arg("output") = BOOTSTRAPPED, - py::arg("p") = 4, - py::arg("mod") = 0) - .def("Decrypt", &binfhe_DecryptWrapper, - binfhe_Decrypt_docs, - py::arg("sk"), - py::arg("ct"), - py::arg("p") = 4) - .def("EvalBinGate", - static_cast(&BinFHEContext::EvalBinGate), - binfhe_EvalBinGate_docs, - py::arg("gate"), - py::arg("ct1"), - py::arg("ct2")) - .def("EvalBinGate", - static_cast &) const>(&BinFHEContext::EvalBinGate), - py::arg("gate"), - py::arg("ctvector") - ) - .def("EvalNOT", &BinFHEContext::EvalNOT, - binfhe_EvalNOT_docs, - py::arg("ct")) - .def("Getn",&GetnWrapper) - .def("Getq",&GetqWrapper) - .def("GetMaxPlaintextSpace",&GetMaxPlaintextSpaceWrapper) - .def("GetBeta",&GetBetaWrapper) - .def("EvalDecomp",&BinFHEContext::EvalDecomp, - binfhe_EvalDecomp_docs, - py::arg("ct")) - .def("EvalFloor",&BinFHEContext::EvalFloor, - binfhe_EvalFloor_docs, - py::arg("ct"), - py::arg("roundbits") = 0) - .def("GenerateLUTviaFunction",&GenerateLUTviaFunctionWrapper, - binfhe_GenerateLUTviaFunction_docs, - py::arg("f"), - py::arg("p")) - .def("EvalFunc",&EvalFuncWrapper, - binfhe_EvalFunc_docs, - py::arg("ct"), - py::arg("LUT")) - .def("EvalSign",&BinFHEContext::EvalSign, - binfhe_EvalSign_docs, - py::arg("ct"), - py::arg("schemeSwitch") = false) - .def("EvalNOT",&BinFHEContext::EvalNOT) - .def("EvalConstant",&BinFHEContext::EvalConstant) - .def("ClearBTKeys",&BinFHEContext::ClearBTKeys) - .def("Bootstrap",&BinFHEContext::Bootstrap,py::arg("ct")) - .def("SerializedVersion",&BinFHEContext::SerializedVersion, - binfhe_SerializedVersion_docs) - .def("SerializedObjectName",&BinFHEContext::SerializedObjectName, - binfhe_SerializedObjectName_docs) - .def("SaveJSON",&BinFHEContext::save) - .def("LoadJSON",&BinFHEContext::load) - .def("SaveBinary",&BinFHEContext::save) - .def("LoadBinary",&BinFHEContext::load) - .def("SavePortableBinary",&BinFHEContext::save) - .def("LoadPortableBinary",&BinFHEContext::load) - .def("GetPublicKey",&BinFHEContext::GetPublicKey) - .def("GetSwitchKey",&BinFHEContext::GetSwitchKey) - .def("GetRefreshKey",&BinFHEContext::GetRefreshKey) - .def("GetBinFHEScheme",&BinFHEContext::GetBinFHEScheme) - .def("GetLWEScheme",&BinFHEContext::GetLWEScheme) - .def("GetParams",&BinFHEContext::GetParams); +void bind_binfhe_context(py::module &m) { + py::class_>(m, "BinFHEContext") + .def(py::init<>()) + .def("GenerateBinFHEContext", + static_cast( + &BinFHEContext::GenerateBinFHEContext), + binfhe_GenerateBinFHEContext_parset_docs, py::arg("set"), + py::arg("method") = GINX) + // void GenerateBinFHEContext(BINFHE_PARAMSET set, bool arbFunc, uint32_t + // logQ = 11, int64_t N = 0, BINFHE_METHOD method = GINX, bool + // timeOptimization = false) + .def("GenerateBinFHEContext", + static_cast( + &BinFHEContext::GenerateBinFHEContext), + binfhe_GenerateBinFHEContext_docs, py::arg("set"), + py::arg("arbFunc"), py::arg("logQ") = 11, py::arg("N") = 0, + py::arg("method") = GINX, py::arg("timeOptimization") = false) + .def("KeyGen", &BinFHEContext::KeyGen, binfhe_KeyGen_docs) + .def("KeyGenN", &BinFHEContext::KeyGenN) + .def("KeyGenPair", &BinFHEContext::KeyGenPair) + .def("BTKeyGen", &BinFHEContext::BTKeyGen, binfhe_BTKeyGen_docs, + py::arg("sk"), py::arg("keygenMode") = SYM_ENCRYPT) + .def("Encrypt", &binfhe_EncryptWrapper, binfhe_Encrypt_docs, + py::arg("sk"), py::arg("m"), py::arg("output") = BOOTSTRAPPED, + py::arg("p") = 4, py::arg("mod") = 0) + .def("Decrypt", &binfhe_DecryptWrapper, binfhe_Decrypt_docs, + py::arg("sk"), py::arg("ct"), py::arg("p") = 4) + .def("EvalBinGate", + static_cast( + &BinFHEContext::EvalBinGate), + binfhe_EvalBinGate_docs, py::arg("gate"), py::arg("ct1"), + py::arg("ct2")) + .def("EvalBinGate", + static_cast &) const>( + &BinFHEContext::EvalBinGate), + py::arg("gate"), py::arg("ctvector")) + .def("EvalNOT", &BinFHEContext::EvalNOT, binfhe_EvalNOT_docs, + py::arg("ct")) + .def("Getn", &GetnWrapper) + .def("Getq", &GetqWrapper) + .def("GetMaxPlaintextSpace", &GetMaxPlaintextSpaceWrapper) + .def("GetBeta", &GetBetaWrapper) + .def("EvalDecomp", &BinFHEContext::EvalDecomp, binfhe_EvalDecomp_docs, + py::arg("ct")) + .def("EvalFloor", &BinFHEContext::EvalFloor, binfhe_EvalFloor_docs, + py::arg("ct"), py::arg("roundbits") = 0) + .def("GenerateLUTviaFunction", &GenerateLUTviaFunctionWrapper, + binfhe_GenerateLUTviaFunction_docs, py::arg("f"), py::arg("p")) + .def("EvalFunc", &EvalFuncWrapper, binfhe_EvalFunc_docs, py::arg("ct"), + py::arg("LUT")) + .def("EvalSign", &BinFHEContext::EvalSign, binfhe_EvalSign_docs, + py::arg("ct"), py::arg("schemeSwitch") = false) + .def("EvalNOT", &BinFHEContext::EvalNOT) + .def("EvalConstant", &BinFHEContext::EvalConstant) + .def("ClearBTKeys", &BinFHEContext::ClearBTKeys) + .def("Bootstrap", &BinFHEContext::Bootstrap, py::arg("ct")) + .def("SerializedVersion", &BinFHEContext::SerializedVersion, + binfhe_SerializedVersion_docs) + .def("SerializedObjectName", &BinFHEContext::SerializedObjectName, + binfhe_SerializedObjectName_docs) + .def("SaveJSON", &BinFHEContext::save) + .def("LoadJSON", &BinFHEContext::load) + .def("SaveBinary", &BinFHEContext::save) + .def("LoadBinary", &BinFHEContext::load) + .def("SavePortableBinary", + &BinFHEContext::save) + .def("LoadPortableBinary", + &BinFHEContext::load) + .def("GetPublicKey", &BinFHEContext::GetPublicKey) + .def("GetSwitchKey", &BinFHEContext::GetSwitchKey) + .def("GetRefreshKey", &BinFHEContext::GetRefreshKey) + .def("GetBinFHEScheme", &BinFHEContext::GetBinFHEScheme) + .def("GetLWEScheme", &BinFHEContext::GetLWEScheme) + .def("GetParams", &BinFHEContext::GetParams); }