KeyPair bindings inited.

cpp/.gitignore

@@ -0,0 +1 @@
+build

cpp/include/bindings.hpp

@@ -141,6 +141,10 @@ enum CryptoContextType {
     // Add other types as needed
 };
 
+// KeyPair FFI forwad declaration
+
+class FFIKeyPair;
+
 // PublicKeyImpl FFI
 
 class FFIPublicKeyImpl {
@@ -149,12 +153,14 @@ protected:
 public:
     FFIPublicKeyImpl();
 
-    void SetKeyTag(const std::string& tag);
+    explicit FFIPublicKeyImpl(void* new_pubkey_ptr);
 
-    const std::string GetKeyTag() const;
-};
+    void SetKeyTag(const char*& tag);
 
-using FFIPublicKey = std::shared_ptr<FFIPublicKeyImpl>;
+    const char* GetKeyTag() const;
+
+    friend class FFIKeyPair;
+};
 
 // PrivateKeyImpl FFI
 
@@ -164,12 +170,32 @@ protected:
 public:
     FFIPrivateKeyImpl();
 
-    void SetKeyTag(const std::string& tag);
+    explicit FFIPrivateKeyImpl(void* new_privkey_ptr);
+
+    void SetKeyTag(const char*& tag);
+
+    const char* GetKeyTag() const;
 
-    const std::string GetKeyTag() const;
+    friend class FFIKeyPair;
 };
 
-using FFIPrivateKey = std::shared_ptr<FFIPrivateKeyImpl>;
+// KeyPair FFI
+
+class FFIKeyPair {
+protected:
+    void* keypair_ptr;
+public:
+    FFIKeyPair();
+
+    explicit FFIKeyPair(const FFIPublicKeyImpl& publicKey, const FFIPrivateKeyImpl& privateKey);
+    
+    // TODO make it a const method
+    bool is_good() ;
+
+    FFIPublicKeyImpl GetPublicKey() const;
+
+    FFIPrivateKeyImpl GetPrivateKey() const;
+};
 
 // Params FFI
 class FFIParams{

cpp/src/bindings.cpp

@@ -31,6 +31,10 @@ namespace {
     struct PrivkeyHolder{
            std::shared_ptr<PrivateKeyImpl<DCRTPoly>> ptr;
     };
+
+    struct KeyPairHolder{
+           std::shared_ptr<KeyPair<DCRTPoly>> ptr;
+    };
 }
 
 FFIParams::FFIParams(){
@@ -1217,43 +1221,85 @@ FFIPublicKeyImpl::FFIPublicKeyImpl(){
         new PubkeyHolder{std::make_shared<PublicKeyImpl<DCRTPoly>>()});
 }
 
-void FFIPublicKeyImpl::SetKeyTag(const std::string& tag){
+FFIPublicKeyImpl::FFIPublicKeyImpl(void * newpubkey_ptr){
+    pubkey_ptr = newpubkey_ptr;
+}
+
+void FFIPublicKeyImpl::SetKeyTag(const char*& tag){
     std::shared_ptr<PublicKeyImpl<DCRTPoly>> pubkey =
         reinterpret_cast<PubkeyHolder*>(pubkey_ptr)->ptr;
     pubkey->SetKeyTag(tag);
 }
 
-const std::string FFIPublicKeyImpl::GetKeyTag() const{
+const char* FFIPublicKeyImpl::GetKeyTag() const{
     std::shared_ptr<const PublicKeyImpl<DCRTPoly>> pubkey =
         reinterpret_cast<PubkeyHolder*>(pubkey_ptr)->ptr;
-    return pubkey->GetKeyTag();
+    return pubkey->GetKeyTag().c_str();
 }
 
-
 FFIPrivateKeyImpl::FFIPrivateKeyImpl(){
     privkey_ptr = reinterpret_cast<void*>(
         new PrivkeyHolder{std::make_shared<PrivateKeyImpl<DCRTPoly>>()});
 }
 
-void FFIPrivateKeyImpl::SetKeyTag(const std::string& tag){
+FFIPrivateKeyImpl::FFIPrivateKeyImpl(void * newprivkey_ptr){
+    privkey_ptr = newprivkey_ptr;
+}
+
+void FFIPrivateKeyImpl::SetKeyTag(const char*& tag){
     std::shared_ptr<PrivateKeyImpl<DCRTPoly>> privkey =
         reinterpret_cast<PrivkeyHolder*>(privkey_ptr)->ptr;
     privkey->SetKeyTag(tag);
 }
 
-const std::string FFIPrivateKeyImpl::GetKeyTag() const{
+const char* FFIPrivateKeyImpl::GetKeyTag() const{
     std::shared_ptr<const PrivateKeyImpl<DCRTPoly>> privkey =
         reinterpret_cast<PrivkeyHolder*>(privkey_ptr)->ptr;
-    return privkey->GetKeyTag();
+    return privkey->GetKeyTag().c_str();
+}
+
+FFIKeyPair::FFIKeyPair(){
+    keypair_ptr = reinterpret_cast<void*>(
+        new KeyPairHolder{std::make_shared<KeyPair<DCRTPoly>>()});
 }
 
+FFIKeyPair::FFIKeyPair(const FFIPublicKeyImpl& pubkey, const FFIPrivateKeyImpl& privkey){
+    keypair_ptr = reinterpret_cast<void*>(
+        new KeyPairHolder{std::make_shared<KeyPair<DCRTPoly>>(
+            reinterpret_cast<PubkeyHolder*>(pubkey.pubkey_ptr)->ptr,
+            reinterpret_cast<PrivkeyHolder*>(privkey.privkey_ptr)->ptr)});
+}
+
+bool FFIKeyPair::is_good() {
+    // TODO make it const method
+    // std::shared_ptr<const KeyPair<DCRTPoly>> keypair =
+    std::shared_ptr<KeyPair<DCRTPoly>> keypair =
+        reinterpret_cast<KeyPairHolder*>(keypair_ptr)->ptr;
+    return keypair->good();
+}
+
+FFIPublicKeyImpl FFIKeyPair::GetPublicKey() const{
+    std::shared_ptr<const KeyPair<DCRTPoly>> keypair =
+        reinterpret_cast<KeyPairHolder*>(keypair_ptr)->ptr;
+
+    void* pubkey_ptr = 
+        reinterpret_cast<void*>(
+            new PubkeyHolder{std::make_shared<PublicKeyImpl<DCRTPoly>>(*(keypair->publicKey))});
+    return FFIPublicKeyImpl{pubkey_ptr};
+}
+
+FFIPrivateKeyImpl FFIKeyPair::GetPrivateKey() const{
+    std::shared_ptr<const KeyPair<DCRTPoly>> keypair =
+        reinterpret_cast<KeyPairHolder*>(keypair_ptr)->ptr;
+
+    void* privkey_ptr = 
+        reinterpret_cast<void*>(
+            new PrivkeyHolder{std::make_shared<PrivateKeyImpl<DCRTPoly>>(*(keypair->secretKey))});
+    return FFIPrivateKeyImpl{privkey_ptr};
+}
 
 // void bind_keys(py::module &m)
 // {
-//     py::class_<KeyPair<DCRTPoly>>(m, "KeyPair")
-//         .def_readwrite("publicKey", &KeyPair<DCRTPoly>::publicKey)
-//         .def_readwrite("secretKey", &KeyPair<DCRTPoly>::secretKey)
-//         .def("good", &KeyPair<DCRTPoly>::good,kp_good_docs);
 //     py::class_<EvalKeyImpl<DCRTPoly>, std::shared_ptr<EvalKeyImpl<DCRTPoly>>>(m, "EvalKey")
 //     .def(py::init<>())
 //         .def("GetKeyTag", &EvalKeyImpl<DCRTPoly>::GetKeyTag)

src/lib.rs

@@ -14,9 +14,7 @@ mod tests {
         unsafe {
             let bfv_params = FFIParams::new1(FFISCHEME_BFVRNS_SCHEME);
 
-            println!("bfv_params: {:?}", bfv_params);
-
-            println!("{}", bfv_params.GetThresholdNumOfParties())
+            println!("bfv_params numofparties{}", bfv_params.GetThresholdNumOfParties())
         }
     }
 
@@ -26,7 +24,15 @@ mod tests {
             let mut ccontext = FFICryptoContextImpl::new();
             ccontext.SetKeyGenLevel(10);
             println!("crypto_context keygenlevel: {:?}", ccontext.GetKeyGenLevel());
-            println!("crypto_context ringdimension: {:?}", ccontext.GetRingDimension())
+            // println!("crypto_context ringdimension: {:?}", ccontext.GetRingDimension())
+        }
+    }
+
+    #[test]
+    fn testKeyPair() {
+        unsafe {
+            let mut key_pair = FFIKeyPair::new();
+            println!("keypair is_good: {:?}", key_pair.is_good());
         }
     }
 }