refactor: reduce code duplication

10 files changed, 440 insertions, 570 deletions

diff --git a/src/core/function/ArchiveFileOperator.cpp b/src/core/function/ArchiveFileOperator.cpp
index 49b50834..808807c4 100644
--- a/src/core/function/ArchiveFileOperator.cpp
+++ b/src/core/function/ArchiveFileOperator.cpp
@@ -85,7 +85,7 @@ auto ArchiveCloseWriteCallback(struct archive *, void *client_data) -> int {
 }
 
 void ArchiveFileOperator::NewArchive2DataExchanger(
-    const QString &target_directory, std::shared_ptr<GFDataExchanger> exchanger,
+    const QString &target_directory, QSharedPointer<GFDataExchanger> exchanger,
     const OperationCallback &cb) {
   RunIOOperaAsync(
       [=](const DataObjectPtr &data_object) -> GFError {
@@ -194,7 +194,7 @@ void ArchiveFileOperator::NewArchive2DataExchanger(
 }
 
 void ArchiveFileOperator::ExtractArchiveFromDataExchanger(
-    std::shared_ptr<GFDataExchanger> ex, const QString &target_path,
+    QSharedPointer<GFDataExchanger> ex, const QString &target_path,
     const OperationCallback &cb) {
   RunIOOperaAsync(
       [=](const DataObjectPtr &data_object) -> GFError {
diff --git a/src/core/function/ArchiveFileOperator.h b/src/core/function/ArchiveFileOperator.h
index 005ea349..ace16d2b 100644
--- a/src/core/function/ArchiveFileOperator.h
+++ b/src/core/function/ArchiveFileOperator.h
@@ -53,7 +53,7 @@ class GPGFRONTEND_CORE_EXPORT ArchiveFileOperator {
    * @param files
    */
   static void NewArchive2DataExchanger(const QString &target_directory,
-                                       std::shared_ptr<GFDataExchanger>,
+                                       QSharedPointer<GFDataExchanger>,
                                        const OperationCallback &cb);
 
   /**
@@ -63,7 +63,7 @@ class GPGFRONTEND_CORE_EXPORT ArchiveFileOperator {
    * @param base_path
    */
   static void ExtractArchiveFromDataExchanger(
-      std::shared_ptr<GFDataExchanger> fd, const QString &target_path,
+      QSharedPointer<GFDataExchanger> fd, const QString &target_path,
       const OperationCallback &cb);
 };
 }  // namespace GpgFrontend
diff --git a/src/core/function/gpg/GpgBasicOperator.cpp b/src/core/function/gpg/GpgBasicOperator.cpp
index 661c1283..cb933d33 100644
--- a/src/core/function/gpg/GpgBasicOperator.cpp
+++ b/src/core/function/gpg/GpgBasicOperator.cpp
@@ -43,29 +43,51 @@ namespace GpgFrontend {
 GpgBasicOperator::GpgBasicOperator(int channel)
     : SingletonFunctionObject<GpgBasicOperator>(channel) {}
 
-void GpgBasicOperator::Encrypt(const KeyArgsList& keys,
-                               const GFBuffer& in_buffer, bool ascii,
-                               const GpgOperationCallback& cb) {
-  RunGpgOperaAsync(
-      [=](const DataObjectPtr& data_object) -> GpgError {
-        if (keys.empty()) return GPG_ERR_CANCELED;
+void SetSignersImpl(GpgContext& ctx_, const KeyArgsList& signers, bool ascii) {
+  auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
 
-        QContainer<gpgme_key_t> recipients(keys.begin(), keys.end());
+  gpgme_signers_clear(ctx);
 
-        // Last entry data_in array has to be nullptr
-        recipients.emplace_back(nullptr);
+  for (const GpgKey& key : signers) {
+    LOG_D() << "signer's key fpr: " << key.GetFingerprint();
+    if (key.IsHasActualSigningCapability()) {
+      auto error = gpgme_signers_add(ctx, gpgme_key_t(key));
+      CheckGpgError(error);
+    }
+  }
+  if (signers.size() != gpgme_signers_count(ctx_.DefaultContext())) {
+    FLOG_D("not all signers added");
+  }
+}
+
+auto EncryptImpl(GpgContext& ctx_, const KeyArgsList& keys,
+                 const GFBuffer& in_buffer, bool ascii,
+                 const DataObjectPtr& data_object) -> GpgError {
+  if (keys.empty()) return GPG_ERR_CANCELED;
+
+  QContainer<gpgme_key_t> recipients(keys.begin(), keys.end());
 
-        GpgData data_in(in_buffer);
-        GpgData data_out;
+  // Last entry data_in array has to be nullptr
+  recipients.emplace_back(nullptr);
 
-        auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
-        auto err = CheckGpgError(gpgme_op_encrypt(ctx, recipients.data(),
-                                                  GPGME_ENCRYPT_ALWAYS_TRUST,
-                                                  data_in, data_out));
-        data_object->Swap({GpgEncryptResult(gpgme_op_encrypt_result(ctx)),
-                           data_out.Read2GFBuffer()});
+  GpgData data_in(in_buffer);
+  GpgData data_out;
+
+  auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
+  auto err = CheckGpgError(gpgme_op_encrypt(
+      ctx, recipients.data(), GPGME_ENCRYPT_ALWAYS_TRUST, data_in, data_out));
+  data_object->Swap({GpgEncryptResult(gpgme_op_encrypt_result(ctx)),
+                     data_out.Read2GFBuffer()});
+
+  return err;
+}
 
-        return err;
+void GpgBasicOperator::Encrypt(const KeyArgsList& keys,
+                               const GFBuffer& in_buffer, bool ascii,
+                               const GpgOperationCallback& cb) {
+  RunGpgOperaAsync(
+      [=](const DataObjectPtr& data_object) {
+        return EncryptImpl(ctx_, keys, in_buffer, ascii, data_object);
       },
       cb, "gpgme_op_encrypt", "2.1.0");
 }
@@ -74,43 +96,32 @@ auto GpgBasicOperator::EncryptSync(const KeyArgsList& keys,
                                    const GFBuffer& in_buffer, bool ascii)
     -> std::tuple<GpgError, DataObjectPtr> {
   return RunGpgOperaSync(
-      [=](const DataObjectPtr& data_object) -> GpgError {
-        if (keys.empty()) return GPG_ERR_CANCELED;
-
-        QContainer<gpgme_key_t> recipients(keys.begin(), keys.end());
-
-        // Last entry data_in array has to be nullptr
-        recipients.emplace_back(nullptr);
+      [=](const DataObjectPtr& data_object) {
+        return EncryptImpl(ctx_, keys, in_buffer, ascii, data_object);
+      },
+      "gpgme_op_encrypt", "2.1.0");
+}
 
-        GpgData data_in(in_buffer);
-        GpgData data_out;
+auto EncryptSymmetricImpl(GpgContext& ctx_, const GFBuffer& in_buffer,
+                          bool ascii,
+                          const DataObjectPtr& data_object) -> GpgError {
+  GpgData data_in(in_buffer);
+  GpgData data_out;
 
-        auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
-        auto err = CheckGpgError(gpgme_op_encrypt(ctx, recipients.data(),
-                                                  GPGME_ENCRYPT_ALWAYS_TRUST,
-                                                  data_in, data_out));
-        data_object->Swap({GpgEncryptResult(gpgme_op_encrypt_result(ctx)),
-                           data_out.Read2GFBuffer()});
+  auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
+  auto err = CheckGpgError(gpgme_op_encrypt(
+      ctx, nullptr, GPGME_ENCRYPT_SYMMETRIC, data_in, data_out));
+  data_object->Swap({GpgEncryptResult(gpgme_op_encrypt_result(ctx)),
+                     data_out.Read2GFBuffer()});
 
-        return err;
-      },
-      "gpgme_op_encrypt", "2.1.0");
+  return err;
 }
 
 void GpgBasicOperator::EncryptSymmetric(const GFBuffer& in_buffer, bool ascii,
                                         const GpgOperationCallback& cb) {
   RunGpgOperaAsync(
-      [=](const DataObjectPtr& data_object) -> GpgError {
-        GpgData data_in(in_buffer);
-        GpgData data_out;
-
-        auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
-        auto err = CheckGpgError(gpgme_op_encrypt(
-            ctx, nullptr, GPGME_ENCRYPT_SYMMETRIC, data_in, data_out));
-        data_object->Swap({GpgEncryptResult(gpgme_op_encrypt_result(ctx)),
-                           data_out.Read2GFBuffer()});
-
-        return err;
+      [=](const DataObjectPtr& data_object) {
+        return EncryptSymmetricImpl(ctx_, in_buffer, ascii, data_object);
       },
       cb, "gpgme_op_encrypt_symmetric", "2.1.0");
 }
@@ -119,35 +130,31 @@ auto GpgBasicOperator::EncryptSymmetricSync(const GFBuffer& in_buffer,
                                             bool ascii)
     -> std::tuple<GpgError, DataObjectPtr> {
   return RunGpgOperaSync(
-      [=](const DataObjectPtr& data_object) -> GpgError {
-        GpgData data_in(in_buffer);
-        GpgData data_out;
-
-        auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
-        auto err = CheckGpgError(gpgme_op_encrypt(
-            ctx, nullptr, GPGME_ENCRYPT_SYMMETRIC, data_in, data_out));
-        data_object->Swap({GpgEncryptResult(gpgme_op_encrypt_result(ctx)),
-                           data_out.Read2GFBuffer()});
-
-        return err;
+      [=](const DataObjectPtr& data_object) {
+        return EncryptSymmetricImpl(ctx_, in_buffer, ascii, data_object);
       },
       "gpgme_op_encrypt_symmetric", "2.1.0");
 }
 
+auto DecryptImpl(GpgContext& ctx_, const GFBuffer& in_buffer,
+                 const DataObjectPtr& data_object) -> GpgError {
+  GpgData data_in(in_buffer);
+  GpgData data_out;
+
+  auto err =
+      CheckGpgError(gpgme_op_decrypt(ctx_.DefaultContext(), data_in, data_out));
+  data_object->Swap(
+      {GpgDecryptResult(gpgme_op_decrypt_result(ctx_.DefaultContext())),
+       data_out.Read2GFBuffer()});
+
+  return err;
+}
+
 void GpgBasicOperator::Decrypt(const GFBuffer& in_buffer,
                                const GpgOperationCallback& cb) {
   RunGpgOperaAsync(
-      [=](const DataObjectPtr& data_object) -> GpgError {
-        GpgData data_in(in_buffer);
-        GpgData data_out;
-
-        auto err = CheckGpgError(
-            gpgme_op_decrypt(ctx_.DefaultContext(), data_in, data_out));
-        data_object->Swap(
-            {GpgDecryptResult(gpgme_op_decrypt_result(ctx_.DefaultContext())),
-             data_out.Read2GFBuffer()});
-
-        return err;
+      [=](const DataObjectPtr& data_object) {
+        return DecryptImpl(ctx_, in_buffer, data_object);
       },
       cb, "gpgme_op_decrypt", "2.1.0");
 }
@@ -155,45 +162,42 @@ void GpgBasicOperator::Decrypt(const GFBuffer& in_buffer,
 auto GpgBasicOperator::DecryptSync(const GFBuffer& in_buffer)
     -> std::tuple<GpgError, DataObjectPtr> {
   return RunGpgOperaSync(
-      [=](const DataObjectPtr& data_object) -> GpgError {
-        GpgData data_in(in_buffer);
-        GpgData data_out;
-
-        auto err = CheckGpgError(
-            gpgme_op_decrypt(ctx_.DefaultContext(), data_in, data_out));
-        data_object->Swap(
-            {GpgDecryptResult(gpgme_op_decrypt_result(ctx_.DefaultContext())),
-             data_out.Read2GFBuffer()});
-
-        return err;
+      [=](const DataObjectPtr& data_object) {
+        return DecryptImpl(ctx_, in_buffer, data_object);
       },
       "gpgme_op_decrypt", "2.1.0");
 }
 
+auto VerifyImpl(GpgContext& ctx_, const GFBuffer& in_buffer,
+                const GFBuffer& sig_buffer,
+                const DataObjectPtr& data_object) -> GpgError {
+  GpgError err;
+
+  GpgData data_in(in_buffer);
+  GpgData data_out;
+
+  if (!sig_buffer.Empty()) {
+    GpgData sig_data(sig_buffer);
+    err = CheckGpgError(
+        gpgme_op_verify(ctx_.DefaultContext(), sig_data, data_in, nullptr));
+  } else {
+    err = CheckGpgError(
+        gpgme_op_verify(ctx_.DefaultContext(), data_in, nullptr, data_out));
+  }
+
+  data_object->Swap({
+      GpgVerifyResult(gpgme_op_verify_result(ctx_.DefaultContext())),
+  });
+
+  return err;
+}
+
 void GpgBasicOperator::Verify(const GFBuffer& in_buffer,
                               const GFBuffer& sig_buffer,
                               const GpgOperationCallback& cb) {
   RunGpgOperaAsync(
       [=](const DataObjectPtr& data_object) -> GpgError {
-        GpgError err;
-
-        GpgData data_in(in_buffer);
-        GpgData data_out;
-
-        if (!sig_buffer.Empty()) {
-          GpgData sig_data(sig_buffer);
-          err = CheckGpgError(gpgme_op_verify(ctx_.DefaultContext(), sig_data,
-                                              data_in, nullptr));
-        } else {
-          err = CheckGpgError(gpgme_op_verify(ctx_.DefaultContext(), data_in,
-                                              nullptr, data_out));
-        }
-
-        data_object->Swap({
-            GpgVerifyResult(gpgme_op_verify_result(ctx_.DefaultContext())),
-        });
-
-        return err;
+        return VerifyImpl(ctx_, in_buffer, sig_buffer, data_object);
       },
       cb, "gpgme_op_verify", "2.1.0");
 }
@@ -202,51 +206,39 @@ auto GpgBasicOperator::VerifySync(const GFBuffer& in_buffer,
                                   const GFBuffer& sig_buffer)
     -> std::tuple<GpgError, DataObjectPtr> {
   return RunGpgOperaSync(
-      [=](const DataObjectPtr& data_object) -> GpgError {
-        GpgError err;
+      [=](const DataObjectPtr& data_object) {
+        return VerifyImpl(ctx_, in_buffer, sig_buffer, data_object);
+      },
+      "gpgme_op_verify", "2.1.0");
+}
 
-        GpgData data_in(in_buffer);
-        GpgData data_out;
+auto SignImpl(GpgContext& ctx_, const KeyArgsList& signers,
+              const GFBuffer& in_buffer, GpgSignMode mode, bool ascii,
+              const DataObjectPtr& data_object) -> GpgError {
+  if (signers.empty()) return GPG_ERR_CANCELED;
 
-        if (!sig_buffer.Empty()) {
-          GpgData sig_data(sig_buffer);
-          err = CheckGpgError(gpgme_op_verify(ctx_.DefaultContext(), sig_data,
-                                              data_in, nullptr));
-        } else {
-          err = CheckGpgError(gpgme_op_verify(ctx_.DefaultContext(), data_in,
-                                              nullptr, data_out));
-        }
+  GpgError err;
 
-        data_object->Swap({
-            GpgVerifyResult(gpgme_op_verify_result(ctx_.DefaultContext())),
-        });
+  // Set Singers of this opera
+  SetSignersImpl(ctx_, signers, ascii);
 
-        return err;
-      },
-      "gpgme_op_verify", "2.1.0");
+  GpgData data_in(in_buffer);
+  GpgData data_out;
+
+  auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
+  err = CheckGpgError(gpgme_op_sign(ctx, data_in, data_out, mode));
+
+  data_object->Swap(
+      {GpgSignResult(gpgme_op_sign_result(ctx)), data_out.Read2GFBuffer()});
+  return err;
 }
 
 void GpgBasicOperator::Sign(const KeyArgsList& signers,
                             const GFBuffer& in_buffer, GpgSignMode mode,
                             bool ascii, const GpgOperationCallback& cb) {
   RunGpgOperaAsync(
-      [=](const DataObjectPtr& data_object) -> GpgError {
-        if (signers.empty()) return GPG_ERR_CANCELED;
-
-        GpgError err;
-
-        // Set Singers of this opera
-        SetSigners(signers, ascii);
-
-        GpgData data_in(in_buffer);
-        GpgData data_out;
-
-        auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
-        err = CheckGpgError(gpgme_op_sign(ctx, data_in, data_out, mode));
-
-        data_object->Swap({GpgSignResult(gpgme_op_sign_result(ctx)),
-                           data_out.Read2GFBuffer()});
-        return err;
+      [=](const DataObjectPtr& data_object) {
+        return SignImpl(ctx_, signers, in_buffer, mode, ascii, data_object);
       },
       cb, "gpgme_op_sign", "2.1.0");
 }
@@ -255,45 +247,35 @@ auto GpgBasicOperator::SignSync(
     const KeyArgsList& signers, const GFBuffer& in_buffer, GpgSignMode mode,
     bool ascii) -> std::tuple<GpgError, DataObjectPtr> {
   return RunGpgOperaSync(
-      [=](const DataObjectPtr& data_object) -> GpgError {
-        if (signers.empty()) return GPG_ERR_CANCELED;
+      [=](const DataObjectPtr& data_object) {
+        return SignImpl(ctx_, signers, in_buffer, mode, ascii, data_object);
+      },
+      "gpgme_op_sign", "2.1.0");
+}
 
-        GpgError err;
+auto DecryptVerifyImpl(GpgContext& ctx_, const GFBuffer& in_buffer,
+                       const DataObjectPtr& data_object) -> GpgError {
+  GpgError err;
 
-        // Set Singers of this opera
-        SetSigners(signers, ascii);
+  GpgData data_in(in_buffer);
+  GpgData data_out;
 
-        GpgData data_in(in_buffer);
-        GpgData data_out;
+  err = CheckGpgError(
+      gpgme_op_decrypt_verify(ctx_.DefaultContext(), data_in, data_out));
 
-        auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
-        err = CheckGpgError(gpgme_op_sign(ctx, data_in, data_out, mode));
+  data_object->Swap(
+      {GpgDecryptResult(gpgme_op_decrypt_result(ctx_.DefaultContext())),
+       GpgVerifyResult(gpgme_op_verify_result(ctx_.DefaultContext())),
+       data_out.Read2GFBuffer()});
 
-        data_object->Swap({GpgSignResult(gpgme_op_sign_result(ctx)),
-                           data_out.Read2GFBuffer()});
-        return err;
-      },
-      "gpgme_op_sign", "2.1.0");
+  return err;
 }
 
 void GpgBasicOperator::DecryptVerify(const GFBuffer& in_buffer,
                                      const GpgOperationCallback& cb) {
   RunGpgOperaAsync(
-      [=](const DataObjectPtr& data_object) -> GpgError {
-        GpgError err;
-
-        GpgData data_in(in_buffer);
-        GpgData data_out;
-
-        err = CheckGpgError(
-            gpgme_op_decrypt_verify(ctx_.DefaultContext(), data_in, data_out));
-
-        data_object->Swap(
-            {GpgDecryptResult(gpgme_op_decrypt_result(ctx_.DefaultContext())),
-             GpgVerifyResult(gpgme_op_verify_result(ctx_.DefaultContext())),
-             data_out.Read2GFBuffer()});
-
-        return err;
+      [=](const DataObjectPtr& data_object) {
+        return DecryptVerifyImpl(ctx_, in_buffer, data_object);
       },
       cb, "gpgme_op_decrypt_verify", "2.1.0");
 }
@@ -302,22 +284,35 @@ auto GpgBasicOperator::DecryptVerifySync(const GFBuffer& in_buffer)
     -> std::tuple<GpgError, DataObjectPtr> {
   return RunGpgOperaSync(
       [=](const DataObjectPtr& data_object) -> GpgError {
-        GpgError err;
+        return DecryptVerifyImpl(ctx_, in_buffer, data_object);
+      },
+      "gpgme_op_decrypt_verify", "2.1.0");
+}
 
-        GpgData data_in(in_buffer);
-        GpgData data_out;
+auto EncryptSignImpl(GpgContext& ctx_, const KeyArgsList& keys,
+                     const KeyArgsList& signers, const GFBuffer& in_buffer,
+                     bool ascii, const DataObjectPtr& data_object) -> GpgError {
+  if (keys.empty() || signers.empty()) return GPG_ERR_CANCELED;
 
-        err = CheckGpgError(
-            gpgme_op_decrypt_verify(ctx_.DefaultContext(), data_in, data_out));
+  GpgError err;
+  QContainer<gpgme_key_t> recipients(keys.begin(), keys.end());
 
-        data_object->Swap(
-            {GpgDecryptResult(gpgme_op_decrypt_result(ctx_.DefaultContext())),
-             GpgVerifyResult(gpgme_op_verify_result(ctx_.DefaultContext())),
-             data_out.Read2GFBuffer()});
+  // Last entry data_in array has to be nullptr
+  recipients.emplace_back(nullptr);
 
-        return err;
-      },
-      "gpgme_op_decrypt_verify", "2.1.0");
+  SetSignersImpl(ctx_, signers, ascii);
+
+  GpgData data_in(in_buffer);
+  GpgData data_out;
+
+  auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
+  err = CheckGpgError(gpgme_op_encrypt_sign(
+      ctx, recipients.data(), GPGME_ENCRYPT_ALWAYS_TRUST, data_in, data_out));
+
+  data_object->Swap({GpgEncryptResult(gpgme_op_encrypt_result(ctx)),
+                     GpgSignResult(gpgme_op_sign_result(ctx)),
+                     data_out.Read2GFBuffer()});
+  return err;
 }
 
 void GpgBasicOperator::EncryptSign(const KeyArgsList& keys,
@@ -326,28 +321,8 @@ void GpgBasicOperator::EncryptSign(const KeyArgsList& keys,
                                    const GpgOperationCallback& cb) {
   RunGpgOperaAsync(
       [=](const DataObjectPtr& data_object) -> GpgError {
-        if (keys.empty() || signers.empty()) return GPG_ERR_CANCELED;
-
-        GpgError err;
-        QContainer<gpgme_key_t> recipients(keys.begin(), keys.end());
-
-        // Last entry data_in array has to be nullptr
-        recipients.emplace_back(nullptr);
-
-        SetSigners(signers, ascii);
-
-        GpgData data_in(in_buffer);
-        GpgData data_out;
-
-        auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
-        err = CheckGpgError(gpgme_op_encrypt_sign(ctx, recipients.data(),
-                                                  GPGME_ENCRYPT_ALWAYS_TRUST,
-                                                  data_in, data_out));
-
-        data_object->Swap({GpgEncryptResult(gpgme_op_encrypt_result(ctx)),
-                           GpgSignResult(gpgme_op_sign_result(ctx)),
-                           data_out.Read2GFBuffer()});
-        return err;
+        return EncryptSignImpl(ctx_, keys, signers, in_buffer, ascii,
+                               data_object);
       },
       cb, "gpgme_op_encrypt_sign", "2.1.0");
 }
@@ -358,47 +333,14 @@ auto GpgBasicOperator::EncryptSignSync(const KeyArgsList& keys,
     -> std::tuple<GpgError, DataObjectPtr> {
   return RunGpgOperaSync(
       [=](const DataObjectPtr& data_object) -> GpgError {
-        if (keys.empty() || signers.empty()) return GPG_ERR_CANCELED;
-
-        GpgError err;
-        QContainer<gpgme_key_t> recipients(keys.begin(), keys.end());
-
-        // Last entry data_in array has to be nullptr
-        recipients.emplace_back(nullptr);
-
-        SetSigners(signers, ascii);
-
-        GpgData data_in(in_buffer);
-        GpgData data_out;
-
-        auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
-        err = CheckGpgError(gpgme_op_encrypt_sign(ctx, recipients.data(),
-                                                  GPGME_ENCRYPT_ALWAYS_TRUST,
-                                                  data_in, data_out));
-
-        data_object->Swap({GpgEncryptResult(gpgme_op_encrypt_result(ctx)),
-                           GpgSignResult(gpgme_op_sign_result(ctx)),
-                           data_out.Read2GFBuffer()});
-        return err;
+        return EncryptSignImpl(ctx_, keys, signers, in_buffer, ascii,
+                               data_object);
       },
       "gpgme_op_encrypt_sign", "2.1.0");
 }
 
 void GpgBasicOperator::SetSigners(const KeyArgsList& signers, bool ascii) {
-  auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
-
-  gpgme_signers_clear(ctx);
-
-  for (const GpgKey& key : signers) {
-    LOG_D() << "signer's key fpr: " << key.GetFingerprint();
-    if (key.IsHasActualSigningCapability()) {
-      auto error = gpgme_signers_add(ctx, gpgme_key_t(key));
-      CheckGpgError(error);
-    }
-  }
-  if (signers.size() != gpgme_signers_count(ctx_.DefaultContext())) {
-    FLOG_D("not all signers added");
-  }
+  SetSignersImpl(ctx_, signers, ascii);
 }
 
 auto GpgBasicOperator::GetSigners(bool ascii) -> KeyArgsList {
diff --git a/src/core/function/gpg/GpgFileOpera.cpp b/src/core/function/gpg/GpgFileOpera.cpp
index 0a321b14..3b2efd52 100644
--- a/src/core/function/gpg/GpgFileOpera.cpp
+++ b/src/core/function/gpg/GpgFileOpera.cpp
@@ -40,31 +40,63 @@
 
 namespace GpgFrontend {
 
-constexpr ssize_t kDataExchangerSize = 8192;
+auto ExtractArchiveHelper(const QString& out_path)
+    -> QSharedPointer<GFDataExchanger> {
+  auto ex = CreateStandardGFDataExchanger();
+  ArchiveFileOperator::ExtractArchiveFromDataExchanger(
+      ex, out_path, [](GFError err, const DataObjectPtr&) {
+        FLOG_D("extract archive from data exchanger operation, err: %d", err);
+      });
+  return ex;
+}
+
+void CreateArchiveHelper(const QString& in_path,
+                         const QSharedPointer<GFDataExchanger>& ex) {
+  auto w_ex = QWeakPointer<GFDataExchanger>(ex);
+
+  ArchiveFileOperator::NewArchive2DataExchanger(
+      in_path, ex, [=](GFError err, const DataObjectPtr&) {
+        FLOG_D("new archive 2 data exchanger operation, err: %d", err);
+        if (decltype(ex) p_ex = w_ex.lock(); err < 0 && p_ex != nullptr) {
+          ex->CloseWrite();
+        }
+      });
+}
 
 GpgFileOpera::GpgFileOpera(int channel)
     : SingletonFunctionObject<GpgFileOpera>(channel) {}
 
+auto EncryptFileGpgDataImpl(GpgContext& ctx_, const KeyArgsList& keys,
+                            GpgData& data_in, bool ascii, GpgData& data_out,
+                            const DataObjectPtr& data_object) -> GpgError {
+  auto recipients = Convert2RawGpgMEKeyList(keys);
+  auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
+
+  auto err = CheckGpgError(
+      gpgme_op_encrypt(ctx, keys.isEmpty() ? nullptr : recipients.data(),
+                       GPGME_ENCRYPT_ALWAYS_TRUST, data_in, data_out));
+  data_object->Swap({GpgEncryptResult(gpgme_op_encrypt_result(ctx))});
+  return err;
+}
+
+auto EncryptFileImpl(GpgContext& ctx_, const KeyArgsList& keys,
+                     const QString& in_path, bool ascii,
+                     const QString& out_path,
+                     const DataObjectPtr& data_object) -> GpgError {
+  GpgData data_in(in_path, true);
+  GpgData data_out(out_path, false);
+
+  return EncryptFileGpgDataImpl(ctx_, keys, data_in, ascii, data_out,
+                                data_object);
+}
+
 void GpgFileOpera::EncryptFile(const KeyArgsList& keys, const QString& in_path,
                                bool ascii, const QString& out_path,
                                const GpgOperationCallback& cb) {
   RunGpgOperaAsync(
-      [=](const DataObjectPtr& data_object) -> GpgError {
-        QContainer<gpgme_key_t> recipients(keys.begin(), keys.end());
-
-        // Last entry data_in array has to be nullptr
-        recipients.emplace_back(nullptr);
-
-        GpgData data_in(in_path, true);
-        GpgData data_out(out_path, false);
-
-        auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
-        auto err = CheckGpgError(gpgme_op_encrypt(ctx, recipients.data(),
-                                                  GPGME_ENCRYPT_ALWAYS_TRUST,
-                                                  data_in, data_out));
-        data_object->Swap({GpgEncryptResult(gpgme_op_encrypt_result(ctx))});
-
-        return err;
+      [=](const DataObjectPtr& data_object) {
+        return EncryptFileImpl(ctx_, keys, in_path, ascii, out_path,
+                               data_object);
       },
       cb, "gpgme_op_encrypt", "2.1.0");
 }
@@ -73,22 +105,9 @@ auto GpgFileOpera::EncryptFileSync(
     const KeyArgsList& keys, const QString& in_path, bool ascii,
     const QString& out_path) -> std::tuple<GpgError, DataObjectPtr> {
   return RunGpgOperaSync(
-      [=](const DataObjectPtr& data_object) -> GpgError {
-        QContainer<gpgme_key_t> recipients(keys.begin(), keys.end());
-
-        // Last entry data_in array has to be nullptr
-        recipients.emplace_back(nullptr);
-
-        GpgData data_in(in_path, true);
-        GpgData data_out(out_path, false);
-
-        auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
-        auto err = CheckGpgError(gpgme_op_encrypt(ctx, recipients.data(),
-                                                  GPGME_ENCRYPT_ALWAYS_TRUST,
-                                                  data_in, data_out));
-        data_object->Swap({GpgEncryptResult(gpgme_op_encrypt_result(ctx))});
-
-        return err;
+      [=](const DataObjectPtr& data_object) {
+        return EncryptFileImpl(ctx_, keys, in_path, ascii, out_path,
+                               data_object);
       },
       "gpgme_op_encrypt", "2.1.0");
 }
@@ -97,54 +116,46 @@ void GpgFileOpera::EncryptDirectory(const KeyArgsList& keys,
                                     const QString& in_path, bool ascii,
                                     const QString& out_path,
                                     const GpgOperationCallback& cb) {
-  auto ex = std::make_shared<GFDataExchanger>(kDataExchangerSize);
-  auto w_ex = std::weak_ptr<GFDataExchanger>(ex);
+  auto ex = CreateStandardGFDataExchanger();
 
   RunGpgOperaAsync(
       [=](const DataObjectPtr& data_object) -> GpgError {
-        QContainer<gpgme_key_t> recipients(keys.begin(), keys.end());
-
-        // Last entry data_in array has to be nullptr
-        recipients.emplace_back(nullptr);
-
         GpgData data_in(ex);
         GpgData data_out(out_path, false);
 
-        FLOG_D("encrypt directory start");
-
-        auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
-        auto err = CheckGpgError(gpgme_op_encrypt(ctx, recipients.data(),
-                                                  GPGME_ENCRYPT_ALWAYS_TRUST,
-                                                  data_in, data_out));
-        data_object->Swap({GpgEncryptResult(gpgme_op_encrypt_result(ctx))});
-
-        FLOG_D("encrypt directory finished, err: %d", err);
-        return err;
+        return EncryptFileGpgDataImpl(ctx_, keys, data_in, ascii, data_out,
+                                      data_object);
       },
       cb, "gpgme_op_encrypt", "2.1.0");
 
-  ArchiveFileOperator::NewArchive2DataExchanger(
-      in_path, ex, [=](GFError err, const DataObjectPtr&) {
-        FLOG_D("new archive 2 data exchanger operation, err: %d", err);
-        if (decltype(ex) p_ex = w_ex.lock(); err < 0 && p_ex != nullptr) {
-          ex->CloseWrite();
-        }
-      });
+  CreateArchiveHelper(in_path, ex);
+}
+
+auto DecryptFileGpgDataImpl(GpgContext& ctx_, GpgData& data_in,
+                            GpgData& data_out,
+                            const DataObjectPtr& data_object) -> GpgError {
+  auto err =
+      CheckGpgError(gpgme_op_decrypt(ctx_.DefaultContext(), data_in, data_out));
+  data_object->Swap(
+      {GpgDecryptResult(gpgme_op_decrypt_result(ctx_.DefaultContext()))});
+
+  return err;
+}
+
+auto DecryptFileImpl(GpgContext& ctx_, const QString& in_path,
+                     const QString& out_path,
+                     const DataObjectPtr& data_object) -> GpgError {
+  GpgData data_in(in_path, true);
+  GpgData data_out(out_path, false);
+
+  return DecryptFileGpgDataImpl(ctx_, data_in, data_out, data_object);
 }
 
 void GpgFileOpera::DecryptFile(const QString& in_path, const QString& out_path,
                                const GpgOperationCallback& cb) {
   RunGpgOperaAsync(
-      [=](const DataObjectPtr& data_object) -> GpgError {
-        GpgData data_in(in_path, true);
-        GpgData data_out(out_path, false);
-
-        auto err = CheckGpgError(
-            gpgme_op_decrypt(ctx_.DefaultContext(), data_in, data_out));
-        data_object->Swap(
-            {GpgDecryptResult(gpgme_op_decrypt_result(ctx_.DefaultContext()))});
-
-        return err;
+      [=](const DataObjectPtr& data_object) {
+        return DecryptFileImpl(ctx_, in_path, out_path, data_object);
       },
       cb, "gpgme_op_decrypt", "2.1.0");
 }
@@ -153,16 +164,8 @@ auto GpgFileOpera::DecryptFileSync(const QString& in_path,
                                    const QString& out_path)
     -> std::tuple<GpgError, DataObjectPtr> {
   return RunGpgOperaSync(
-      [=](const DataObjectPtr& data_object) -> GpgError {
-        GpgData data_in(in_path, true);
-        GpgData data_out(out_path, false);
-
-        auto err = CheckGpgError(
-            gpgme_op_decrypt(ctx_.DefaultContext(), data_in, data_out));
-        data_object->Swap(
-            {GpgDecryptResult(gpgme_op_decrypt_result(ctx_.DefaultContext()))});
-
-        return err;
+      [=](const DataObjectPtr& data_object) {
+        return DecryptFileImpl(ctx_, in_path, out_path, data_object);
       },
       "gpgme_op_decrypt", "2.1.0");
 }
@@ -170,49 +173,55 @@ auto GpgFileOpera::DecryptFileSync(const QString& in_path,
 void GpgFileOpera::DecryptArchive(const QString& in_path,
                                   const QString& out_path,
                                   const GpgOperationCallback& cb) {
-  auto ex = std::make_shared<GFDataExchanger>(kDataExchangerSize);
-
-  ArchiveFileOperator::ExtractArchiveFromDataExchanger(
-      ex, out_path, [](GFError err, const DataObjectPtr&) {
-        FLOG_D("extract archive from data exchanger operation, err: %d", err);
-      });
+  auto ex = ExtractArchiveHelper(out_path);
 
   RunGpgOperaAsync(
       [=](const DataObjectPtr& data_object) -> GpgError {
         GpgData data_in(in_path, true);
         GpgData data_out(ex);
 
-        auto err = CheckGpgError(
-            gpgme_op_decrypt(ctx_.DefaultContext(), data_in, data_out));
-
-        data_object->Swap(
-            {GpgDecryptResult(gpgme_op_decrypt_result(ctx_.DefaultContext()))});
-        return err;
+        return DecryptFileGpgDataImpl(ctx_, data_in, data_out, data_object);
       },
       cb, "gpgme_op_decrypt", "2.1.0");
 }
 
-void GpgFileOpera::SignFile(const KeyArgsList& keys, const QString& in_path,
-                            bool ascii, const QString& out_path,
-                            const GpgOperationCallback& cb) {
-  RunGpgOperaAsync(
-      [=](const DataObjectPtr& data_object) -> GpgError {
-        GpgError err;
+auto SignFileGpgDataImpl(GpgContext& ctx_, GpgBasicOperator& basic_opera_,
+                         const KeyArgsList& keys, GpgData& data_in, bool ascii,
+                         GpgData& data_out,
+                         const DataObjectPtr& data_object) -> GpgError {
+  GpgError err;
 
-        // Set Singers of this opera
-        GpgBasicOperator::GetInstance(GetChannel()).SetSigners(keys, ascii);
+  // Set Singers of this opera
+  basic_opera_.SetSigners(keys, ascii);
 
-        GpgData data_in(in_path, true);
-        GpgData data_out(out_path, false);
+  auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
+  err = CheckGpgError(
+      gpgme_op_sign(ctx, data_in, data_out, GPGME_SIG_MODE_DETACH));
+
+  data_object->Swap({
+      GpgSignResult(gpgme_op_sign_result(ctx)),
+  });
+  return err;
+}
+
+auto SignFileImpl(GpgContext& ctx_, GpgBasicOperator& basic_opera_,
+                  const KeyArgsList& keys, const QString& in_path, bool ascii,
+                  const QString& out_path,
+                  const DataObjectPtr& data_object) -> GpgError {
+  GpgData data_in(in_path, true);
+  GpgData data_out(out_path, false);
 
-        auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
-        err = CheckGpgError(
-            gpgme_op_sign(ctx, data_in, data_out, GPGME_SIG_MODE_DETACH));
+  return SignFileGpgDataImpl(ctx_, basic_opera_, keys, data_in, ascii, data_out,
+                             data_object);
+}
 
-        data_object->Swap({
-            GpgSignResult(gpgme_op_sign_result(ctx)),
-        });
-        return err;
+void GpgFileOpera::SignFile(const KeyArgsList& keys, const QString& in_path,
+                            bool ascii, const QString& out_path,
+                            const GpgOperationCallback& cb) {
+  RunGpgOperaAsync(
+      [=](const DataObjectPtr& data_object) {
+        return SignFileImpl(ctx_, basic_opera_, keys, in_path, ascii, out_path,
+                            data_object);
       },
       cb, "gpgme_op_sign", "2.1.0");
 }
@@ -221,50 +230,42 @@ auto GpgFileOpera::SignFileSync(const KeyArgsList& keys, const QString& in_path,
                                 bool ascii, const QString& out_path)
     -> std::tuple<GpgError, DataObjectPtr> {
   return RunGpgOperaSync(
-      [=](const DataObjectPtr& data_object) -> GpgError {
-        GpgError err;
-
-        // Set Singers of this opera
-        GpgBasicOperator::GetInstance(GetChannel()).SetSigners(keys, ascii);
-
-        GpgData data_in(in_path, true);
-        GpgData data_out(out_path, false);
-
-        auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
-        err = CheckGpgError(
-            gpgme_op_sign(ctx, data_in, data_out, GPGME_SIG_MODE_DETACH));
-
-        data_object->Swap({
-            GpgSignResult(gpgme_op_sign_result(ctx)),
-        });
-        return err;
+      [=](const DataObjectPtr& data_object) {
+        return SignFileImpl(ctx_, basic_opera_, keys, in_path, ascii, out_path,
+                            data_object);
       },
       "gpgme_op_sign", "2.1.0");
 }
 
+auto VerifyFileImpl(GpgContext& ctx_, const QString& data_path,
+                    const QString& sign_path,
+                    const DataObjectPtr& data_object) -> GpgError {
+  GpgError err;
+
+  GpgData data_in(data_path, true);
+  GpgData data_out;
+  if (!sign_path.isEmpty()) {
+    GpgData sig_data(sign_path, true);
+    err = CheckGpgError(
+        gpgme_op_verify(ctx_.DefaultContext(), sig_data, data_in, nullptr));
+  } else {
+    err = CheckGpgError(
+        gpgme_op_verify(ctx_.DefaultContext(), data_in, nullptr, data_out));
+  }
+
+  data_object->Swap({
+      GpgVerifyResult(gpgme_op_verify_result(ctx_.DefaultContext())),
+  });
+
+  return err;
+}
+
 void GpgFileOpera::VerifyFile(const QString& data_path,
                               const QString& sign_path,
                               const GpgOperationCallback& cb) {
   RunGpgOperaAsync(
       [=](const DataObjectPtr& data_object) -> GpgError {
-        GpgError err;
-
-        GpgData data_in(data_path, true);
-        GpgData data_out;
-        if (!sign_path.isEmpty()) {
-          GpgData sig_data(sign_path, true);
-          err = CheckGpgError(gpgme_op_verify(ctx_.DefaultContext(), sig_data,
-                                              data_in, nullptr));
-        } else {
-          err = CheckGpgError(gpgme_op_verify(ctx_.DefaultContext(), data_in,
-                                              nullptr, data_out));
-        }
-
-        data_object->Swap({
-            GpgVerifyResult(gpgme_op_verify_result(ctx_.DefaultContext())),
-        });
-
-        return err;
+        return VerifyFileImpl(ctx_, data_path, sign_path, data_object);
       },
       cb, "gpgme_op_verify", "2.1.0");
 }
@@ -274,57 +275,55 @@ auto GpgFileOpera::VerifyFileSync(const QString& data_path,
     -> std::tuple<GpgError, DataObjectPtr> {
   return RunGpgOperaSync(
       [=](const DataObjectPtr& data_object) -> GpgError {
-        GpgError err;
-
-        GpgData data_in(data_path, true);
-        GpgData data_out;
-        if (!sign_path.isEmpty()) {
-          GpgData sig_data(sign_path, true);
-          err = CheckGpgError(gpgme_op_verify(ctx_.DefaultContext(), sig_data,
-                                              data_in, nullptr));
-        } else {
-          err = CheckGpgError(gpgme_op_verify(ctx_.DefaultContext(), data_in,
-                                              nullptr, data_out));
-        }
-
-        data_object->Swap({
-            GpgVerifyResult(gpgme_op_verify_result(ctx_.DefaultContext())),
-        });
-
-        return err;
+        return VerifyFileImpl(ctx_, data_path, sign_path, data_object);
       },
       "gpgme_op_verify", "2.1.0");
 }
 
+auto EncryptSignFileGpgDataImpl(GpgContext& ctx_,
+                                GpgBasicOperator& basic_opera_,
+                                const KeyArgsList& keys,
+                                const KeyArgsList& signer_keys,
+                                GpgData& data_in, bool ascii, GpgData& data_out,
+                                const DataObjectPtr& data_object) -> GpgError {
+  GpgError err;
+  auto recipients = Convert2RawGpgMEKeyList(keys);
+
+  basic_opera_.SetSigners(signer_keys, ascii);
+
+  auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
+  err = CheckGpgError(gpgme_op_encrypt_sign(
+      ctx, recipients.data(), GPGME_ENCRYPT_ALWAYS_TRUST, data_in, data_out));
+
+  data_object->Swap({
+      GpgEncryptResult(gpgme_op_encrypt_result(ctx)),
+      GpgSignResult(gpgme_op_sign_result(ctx)),
+  });
+
+  return err;
+}
+
+auto EncryptSignFileImpl(GpgContext& ctx_, GpgBasicOperator& basic_opera_,
+                         const KeyArgsList& keys,
+                         const KeyArgsList& signer_keys, const QString& in_path,
+                         bool ascii, const QString& out_path,
+                         const DataObjectPtr& data_object) -> GpgError {
+  GpgData data_in(in_path, true);
+  GpgData data_out(out_path, false);
+
+  return EncryptSignFileGpgDataImpl(ctx_, basic_opera_, keys, signer_keys,
+                                    data_in, ascii, data_out, data_object);
+}
+
 void GpgFileOpera::EncryptSignFile(const KeyArgsList& keys,
                                    const KeyArgsList& signer_keys,
                                    const QString& in_path, bool ascii,
                                    const QString& out_path,
                                    const GpgOperationCallback& cb) {
   RunGpgOperaAsync(
-      [=](const DataObjectPtr& data_object) -> GpgError {
-        GpgError err;
-        QContainer<gpgme_key_t> recipients(keys.begin(), keys.end());
-
-        // Last entry data_in array has to be nullptr
-        recipients.emplace_back(nullptr);
-
-        GpgBasicOperator::GetInstance(GetChannel())
-            .SetSigners(signer_keys, ascii);
-
-        GpgData data_in(in_path, true);
-        GpgData data_out(out_path, false);
-
-        auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
-        err = CheckGpgError(gpgme_op_encrypt_sign(ctx, recipients.data(),
-                                                  GPGME_ENCRYPT_ALWAYS_TRUST,
-                                                  data_in, data_out));
-
-        data_object->Swap({
-            GpgEncryptResult(gpgme_op_encrypt_result(ctx)),
-            GpgSignResult(gpgme_op_sign_result(ctx)),
-        });
-        return err;
+      [=](const DataObjectPtr& data_object) {
+        return EncryptSignFileImpl(ctx_, basic_opera_, keys, signer_keys,
+                                   in_path, ascii, out_path, data_object);
       },
       cb, "gpgme_op_encrypt_sign", "2.1.0");
 }
@@ -334,29 +333,9 @@ auto GpgFileOpera::EncryptSignFileSync(
     const QString& in_path, bool ascii,
     const QString& out_path) -> std::tuple<GpgError, DataObjectPtr> {
   return RunGpgOperaSync(
-      [=](const DataObjectPtr& data_object) -> GpgError {
-        GpgError err;
-        QContainer<gpgme_key_t> recipients(keys.begin(), keys.end());
-
-        // Last entry data_in array has to be nullptr
-        recipients.emplace_back(nullptr);
-
-        GpgBasicOperator::GetInstance(GetChannel())
-            .SetSigners(signer_keys, ascii);
-
-        GpgData data_in(in_path, true);
-        GpgData data_out(out_path, false);
-
-        auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
-        err = CheckGpgError(gpgme_op_encrypt_sign(ctx, recipients.data(),
-                                                  GPGME_ENCRYPT_ALWAYS_TRUST,
-                                                  data_in, data_out));
-
-        data_object->Swap({
-            GpgEncryptResult(gpgme_op_encrypt_result(ctx)),
-            GpgSignResult(gpgme_op_sign_result(ctx)),
-        });
-        return err;
+      [=](const DataObjectPtr& data_object) {
+        return EncryptSignFileImpl(ctx_, basic_opera_, keys, signer_keys,
+                                   in_path, ascii, out_path, data_object);
       },
       "gpgme_op_encrypt_sign", "2.1.0");
 }
@@ -366,43 +345,42 @@ void GpgFileOpera::EncryptSignDirectory(const KeyArgsList& keys,
                                         const QString& in_path, bool ascii,
                                         const QString& out_path,
                                         const GpgOperationCallback& cb) {
-  auto ex = std::make_shared<GFDataExchanger>(kDataExchangerSize);
-  auto w_ex = std::weak_ptr<GFDataExchanger>(ex);
+  auto ex = CreateStandardGFDataExchanger();
 
   RunGpgOperaAsync(
       [=](const DataObjectPtr& data_object) -> GpgError {
-        GpgError err;
-        QContainer<gpgme_key_t> recipients(keys.begin(), keys.end());
-
-        // Last entry data_in array has to be nullptr
-        recipients.emplace_back(nullptr);
-
-        GpgBasicOperator::GetInstance(GetChannel())
-            .SetSigners(signer_keys, ascii);
-
         GpgData data_in(ex);
         GpgData data_out(out_path, false);
 
-        auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
-        err = CheckGpgError(gpgme_op_encrypt_sign(ctx, recipients.data(),
-                                                  GPGME_ENCRYPT_ALWAYS_TRUST,
-                                                  data_in, data_out));
-
-        data_object->Swap({
-            GpgEncryptResult(gpgme_op_encrypt_result(ctx)),
-            GpgSignResult(gpgme_op_sign_result(ctx)),
-        });
-        return err;
+        return EncryptSignFileGpgDataImpl(ctx_, basic_opera_, keys, signer_keys,
+                                          data_in, ascii, data_out,
+                                          data_object);
       },
       cb, "gpgme_op_encrypt_sign", "2.1.0");
 
-  ArchiveFileOperator::NewArchive2DataExchanger(
-      in_path, ex, [=](GFError err, const DataObjectPtr&) {
-        FLOG_D("new archive 2 fd operation, err: %d", err);
-        if (decltype(ex) p_ex = w_ex.lock(); err < 0 && p_ex != nullptr) {
-          ex->CloseWrite();
-        }
-      });
+  CreateArchiveHelper(in_path, ex);
+}
+
+auto DecryptVerifyFileGpgDataImpl(
+    GpgContext& ctx_, GpgData& data_in, GpgData& data_out,
+    const DataObjectPtr& data_object) -> GpgError {
+  auto err = CheckGpgError(
+      gpgme_op_decrypt_verify(ctx_.DefaultContext(), data_in, data_out));
+
+  data_object->Swap({
+      GpgDecryptResult(gpgme_op_decrypt_result(ctx_.DefaultContext())),
+      GpgVerifyResult(gpgme_op_verify_result(ctx_.DefaultContext())),
+  });
+  return err;
+}
+
+auto DecryptVerifyFileImpl(GpgContext& ctx_, const QString& in_path,
+                           const QString& out_path,
+                           const DataObjectPtr& data_object) -> GpgError {
+  GpgData data_in(in_path, true);
+  GpgData data_out(out_path, false);
+
+  return DecryptVerifyFileGpgDataImpl(ctx_, data_in, data_out, data_object);
 }
 
 void GpgFileOpera::DecryptVerifyFile(const QString& in_path,
@@ -410,20 +388,7 @@ void GpgFileOpera::DecryptVerifyFile(const QString& in_path,
                                      const GpgOperationCallback& cb) {
   RunGpgOperaAsync(
       [=](const DataObjectPtr& data_object) -> GpgError {
-        GpgError err;
-
-        GpgData data_in(in_path, true);
-        GpgData data_out(out_path, false);
-
-        err = CheckGpgError(
-            gpgme_op_decrypt_verify(ctx_.DefaultContext(), data_in, data_out));
-
-        data_object->Swap({
-            GpgDecryptResult(gpgme_op_decrypt_result(ctx_.DefaultContext())),
-            GpgVerifyResult(gpgme_op_verify_result(ctx_.DefaultContext())),
-        });
-
-        return err;
+        return DecryptVerifyFileImpl(ctx_, in_path, out_path, data_object);
       },
       cb, "gpgme_op_decrypt_verify", "2.1.0");
 }
@@ -433,20 +398,7 @@ auto GpgFileOpera::DecryptVerifyFileSync(const QString& in_path,
     -> std::tuple<GpgError, DataObjectPtr> {
   return RunGpgOperaSync(
       [=](const DataObjectPtr& data_object) -> GpgError {
-        GpgError err;
-
-        GpgData data_in(in_path, true);
-        GpgData data_out(out_path, false);
-
-        err = CheckGpgError(
-            gpgme_op_decrypt_verify(ctx_.DefaultContext(), data_in, data_out));
-
-        data_object->Swap({
-            GpgDecryptResult(gpgme_op_decrypt_result(ctx_.DefaultContext())),
-            GpgVerifyResult(gpgme_op_verify_result(ctx_.DefaultContext())),
-        });
-
-        return err;
+        return DecryptVerifyFileImpl(ctx_, in_path, out_path, data_object);
       },
       "gpgme_op_decrypt_verify", "2.1.0");
 }
@@ -454,29 +406,14 @@ auto GpgFileOpera::DecryptVerifyFileSync(const QString& in_path,
 void GpgFileOpera::DecryptVerifyArchive(const QString& in_path,
                                         const QString& out_path,
                                         const GpgOperationCallback& cb) {
-  auto ex = std::make_shared<GFDataExchanger>(kDataExchangerSize);
-
-  ArchiveFileOperator::ExtractArchiveFromDataExchanger(
-      ex, out_path, [](GFError err, const DataObjectPtr&) {
-        FLOG_D("extract archive from ex operation, err: %d", err);
-      });
+  auto ex = ExtractArchiveHelper(out_path);
 
   RunGpgOperaAsync(
       [=](const DataObjectPtr& data_object) -> GpgError {
-        GpgError err;
-
         GpgData data_in(in_path, true);
         GpgData data_out(ex);
-
-        err = CheckGpgError(
-            gpgme_op_decrypt_verify(ctx_.DefaultContext(), data_in, data_out));
-
-        data_object->Swap({
-            GpgDecryptResult(gpgme_op_decrypt_result(ctx_.DefaultContext())),
-            GpgVerifyResult(gpgme_op_verify_result(ctx_.DefaultContext())),
-        });
-
-        return err;
+        return DecryptVerifyFileGpgDataImpl(ctx_, data_in, data_out,
+                                            data_object);
       },
       cb, "gpgme_op_decrypt_verify", "2.1.0");
 }
@@ -486,17 +423,7 @@ void GpgFileOpera::EncryptFileSymmetric(const QString& in_path, bool ascii,
                                         const GpgOperationCallback& cb) {
   RunGpgOperaAsync(
       [=](const DataObjectPtr& data_object) -> GpgError {
-        GpgData data_in(in_path, true);
-        GpgData data_out(out_path, false);
-
-        auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
-        auto err = CheckGpgError(gpgme_op_encrypt(
-            ctx, nullptr, GPGME_ENCRYPT_SYMMETRIC, data_in, data_out));
-        data_object->Swap({
-            GpgEncryptResult(gpgme_op_encrypt_result(ctx)),
-        });
-
-        return err;
+        return EncryptFileImpl(ctx_, {}, in_path, ascii, out_path, data_object);
       },
       cb, "gpgme_op_encrypt_symmetric", "2.1.0");
 }
@@ -506,17 +433,7 @@ auto GpgFileOpera::EncryptFileSymmetricSync(const QString& in_path, bool ascii,
     -> std::tuple<GpgError, DataObjectPtr> {
   return RunGpgOperaSync(
       [=](const DataObjectPtr& data_object) -> GpgError {
-        GpgData data_in(in_path, true);
-        GpgData data_out(out_path, false);
-
-        auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
-        auto err = CheckGpgError(gpgme_op_encrypt(
-            ctx, nullptr, GPGME_ENCRYPT_SYMMETRIC, data_in, data_out));
-        data_object->Swap({
-            GpgEncryptResult(gpgme_op_encrypt_result(ctx)),
-        });
-
-        return err;
+        return EncryptFileImpl(ctx_, {}, in_path, ascii, out_path, data_object);
       },
       "gpgme_op_encrypt_symmetric", "2.1.0");
 }
@@ -524,55 +441,37 @@ auto GpgFileOpera::EncryptFileSymmetricSync(const QString& in_path, bool ascii,
 void GpgFileOpera::EncryptDirectorySymmetric(const QString& in_path, bool ascii,
                                              const QString& out_path,
                                              const GpgOperationCallback& cb) {
-  auto ex = std::make_shared<GFDataExchanger>(kDataExchangerSize);
+  auto ex = CreateStandardGFDataExchanger();
 
   RunGpgOperaAsync(
-      [=](const DataObjectPtr& data_object) -> GpgError {
+      [=](const DataObjectPtr& data_object) {
         GpgData data_in(ex);
         GpgData data_out(out_path, false);
 
-        auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
-        auto err = CheckGpgError(gpgme_op_encrypt(
-            ctx, nullptr, GPGME_ENCRYPT_SYMMETRIC, data_in, data_out));
-        data_object->Swap({
-            GpgEncryptResult(gpgme_op_encrypt_result(ctx)),
-        });
-
-        return err;
+        return EncryptFileGpgDataImpl(ctx_, {}, data_in, ascii, data_out,
+                                      data_object);
       },
       cb, "gpgme_op_encrypt_symmetric", "2.1.0");
 
-  ArchiveFileOperator::NewArchive2DataExchanger(
-      in_path, ex, [=](GFError err, const DataObjectPtr&) {
-        FLOG_D("new archive 2 fd operation, err: %d", err);
-      });
+  CreateArchiveHelper(in_path, ex);
 }
 
 auto GpgFileOpera::EncryptDirectorySymmetricSync(
     const QString& in_path, bool ascii,
     const QString& out_path) -> std::tuple<GpgError, DataObjectPtr> {
-  auto ex = std::make_shared<GFDataExchanger>(kDataExchangerSize);
-
-  ArchiveFileOperator::NewArchive2DataExchanger(
-      in_path, ex, [=](GFError err, const DataObjectPtr&) {
-        FLOG_D("new archive 2 fd operation, err: %d", err);
-      });
+  auto ex = CreateStandardGFDataExchanger();
 
   return RunGpgOperaSync(
       [=](const DataObjectPtr& data_object) -> GpgError {
         GpgData data_in(ex);
         GpgData data_out(out_path, false);
 
-        auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
-        auto err = CheckGpgError(gpgme_op_encrypt(
-            ctx, nullptr, GPGME_ENCRYPT_SYMMETRIC, data_in, data_out));
-        data_object->Swap({
-            GpgEncryptResult(gpgme_op_encrypt_result(ctx)),
-        });
-
-        return err;
+        return EncryptFileGpgDataImpl(ctx_, {}, data_in, ascii, data_out,
+                                      data_object);
       },
       "gpgme_op_encrypt_symmetric", "2.1.0");
+
+  CreateArchiveHelper(in_path, ex);
 }
 
 }  // namespace GpgFrontend
\ No newline at end of file
diff --git a/src/core/function/gpg/GpgFileOpera.h b/src/core/function/gpg/GpgFileOpera.h
index 8bb08567..5119bb36 100644
--- a/src/core/function/gpg/GpgFileOpera.h
+++ b/src/core/function/gpg/GpgFileOpera.h
@@ -29,8 +29,8 @@
 #pragma once
 
 #include "core/function/basic/GpgFunctionObject.h"
+#include "core/function/gpg/GpgBasicOperator.h"
 #include "core/function/gpg/GpgContext.h"
-#include "core/function/result_analyse/GpgResultAnalyse.h"
 #include "core/typedef/GpgTypedef.h"
 
 namespace GpgFrontend {
@@ -296,6 +296,9 @@ class GPGFRONTEND_CORE_EXPORT GpgFileOpera
  private:
   GpgContext& ctx_ = GpgContext::GetInstance(
       SingletonFunctionObject::GetChannel());  ///< Corresponding context
+
+  GpgBasicOperator& basic_opera_ =
+      GpgBasicOperator::GetInstance(SingletonFunctionObject::GetChannel());
 };
 
 }  // namespace GpgFrontend
diff --git a/src/core/model/GFDataExchanger.h b/src/core/model/GFDataExchanger.h
index dca27b0e..1082b011 100644
--- a/src/core/model/GFDataExchanger.h
+++ b/src/core/model/GFDataExchanger.h
@@ -28,10 +28,14 @@
 
 #pragma once
 
+#include <cstddef>
 #include <queue>
 
 namespace GpgFrontend {
 
+constexpr ssize_t kDataExchangerSize =
+    static_cast<const ssize_t>(1024 * 1024 * 8);  // 8 MB
+
 class GFDataExchanger {
  public:
   explicit GFDataExchanger(ssize_t size);
@@ -50,4 +54,8 @@ class GFDataExchanger {
   std::atomic_bool close_ = false;
 };
 
+inline auto CreateStandardGFDataExchanger() -> QSharedPointer<GFDataExchanger> {
+  return QSharedPointer<GFDataExchanger>::create(kDataExchangerSize);
+}
+
 }  // namespace GpgFrontend
\ No newline at end of file
diff --git a/src/core/model/GpgData.cpp b/src/core/model/GpgData.cpp
index 34992b9b..7453ae48 100644
--- a/src/core/model/GpgData.cpp
+++ b/src/core/model/GpgData.cpp
@@ -104,7 +104,7 @@ GpgData::GpgData(const QString& path, bool read) {
   data_ref_ = std::unique_ptr<struct gpgme_data, DataRefDeleter>(data);
 }
 
-GpgData::GpgData(std::shared_ptr<GFDataExchanger> ex)
+GpgData::GpgData(QSharedPointer<GFDataExchanger> ex)
     : data_cbs_(), data_ex_(std::move(ex)) {
   gpgme_data_t data;
 
diff --git a/src/core/model/GpgData.h b/src/core/model/GpgData.h
index ed56d0da..7f1d74c4 100644
--- a/src/core/model/GpgData.h
+++ b/src/core/model/GpgData.h
@@ -71,7 +71,7 @@ class GPGFRONTEND_CORE_EXPORT GpgData {
    *
    * @param fd
    */
-  explicit GpgData(std::shared_ptr<GFDataExchanger>);
+  explicit GpgData(QSharedPointer<GFDataExchanger>);
 
   /**
    * @brief Construct a new Gpg Data object
@@ -124,7 +124,7 @@ class GPGFRONTEND_CORE_EXPORT GpgData {
   int fd_ = -1;
 
   struct gpgme_data_cbs data_cbs_;
-  std::shared_ptr<GFDataExchanger> data_ex_;
+  QSharedPointer<GFDataExchanger> data_ex_;
 };
 
 }  // namespace GpgFrontend
diff --git a/src/core/utils/GpgUtils.cpp b/src/core/utils/GpgUtils.cpp
index bfbee963..ec0f35e2 100644
--- a/src/core/utils/GpgUtils.cpp
+++ b/src/core/utils/GpgUtils.cpp
@@ -29,6 +29,7 @@
 #include "GpgUtils.h"
 
 #include "core/function/GlobalSettingStation.h"
+#include "core/model/GpgKey.h"
 #include "core/model/KeyDatabaseInfo.h"
 #include "core/model/SettingsObject.h"
 #include "core/module/ModuleManager.h"
@@ -324,4 +325,12 @@ auto GetKeyDatabaseInfoBySettings() -> QList<KeyDatabaseInfo> {
 
   return key_db_infos;
 }
+
+auto GPGFRONTEND_CORE_EXPORT Convert2RawGpgMEKeyList(
+    const QContainer<GpgKey>& keys) -> QContainer<gpgme_key_t> {
+  QContainer<gpgme_key_t> recipients(keys.begin(), keys.end());
+  recipients.emplace_back(nullptr);
+
+  return recipients;
+}
 }  // namespace GpgFrontend
diff --git a/src/core/utils/GpgUtils.h b/src/core/utils/GpgUtils.h
index ab0c328f..89f3720a 100644
--- a/src/core/utils/GpgUtils.h
+++ b/src/core/utils/GpgUtils.h
@@ -147,4 +147,13 @@ auto GPGFRONTEND_CORE_EXPORT GetGpgKeyDatabaseInfos() -> QList<KeyDatabaseInfo>;
  */
 auto GPGFRONTEND_CORE_EXPORT GetGpgKeyDatabaseName(int channel) -> QString;
 
+/**
+ * @brief
+ *
+ * @param keys
+ * @return QContainer<gpgme_key_t>
+ */
+auto GPGFRONTEND_CORE_EXPORT Convert2RawGpgMEKeyList(
+    const QContainer<GpgKey>& keys) -> QContainer<gpgme_key_t>;
+
 }  // namespace GpgFrontend
\ No newline at end of file