Merge branch 'dev/2.1.5/mingw' into develop

1 files changed, 207 insertions, 1 deletions

diff --git a/src/sdk/GFSDKGpg.cpp b/src/sdk/GFSDKGpg.cpp
index 88162ffa..52ea0520 100644
--- a/src/sdk/GFSDKGpg.cpp
+++ b/src/sdk/GFSDKGpg.cpp
@@ -24,4 +24,210 @@
  *
  * SPDX-License-Identifier: GPL-3.0-or-later
  *
- */
\ No newline at end of file
+ */
+
+#include "GFSDKGpg.h"
+
+#include "GFSDKBasic.h"
+#include "core/function/gpg/GpgBasicOperator.h"
+#include "core/function/gpg/GpgKeyGetter.h"
+#include "core/function/gpg/GpgKeyImportExporter.h"
+#include "core/model/DataObject.h"
+#include "core/model/GpgDecryptResult.h"
+#include "core/model/GpgEncryptResult.h"
+#include "core/model/GpgSignResult.h"
+#include "core/model/GpgVerifyResult.h"
+#include "core/typedef/GpgTypedef.h"
+#include "core/utils/GpgUtils.h"
+#include "ui/UIModuleManager.h"
+
+//
+#include "private/GFSDKPrivat.h"
+
+auto GPGFRONTEND_MODULE_SDK_EXPORT GFGpgSignData(int channel, char** key_ids,
+                                                 int key_ids_size, char* data,
+                                                 int sign_mode, int ascii,
+                                                 GFGpgSignResult** ps) -> int {
+  auto singer_ids = CharArrayToQList(key_ids, key_ids_size);
+
+  GpgFrontend::KeyArgsList signer_keys;
+  for (const auto& signer_id : singer_ids) {
+    auto key =
+        GpgFrontend::GpgKeyGetter::GetInstance(channel).GetKey(signer_id);
+    if (key.IsGood()) signer_keys.push_back(key);
+  }
+
+  if (signer_keys.empty()) return -1;
+
+  auto in_buffer = GpgFrontend::GFBuffer(GFUnStrDup(data).toUtf8());
+
+  auto gpg_sign_mode =
+      sign_mode == 0 ? GPGME_SIG_MODE_NORMAL : GPGME_SIG_MODE_DETACH;
+
+  auto [err, data_object] =
+      GpgFrontend::GpgBasicOperator::GetInstance(channel).SignSync(
+          signer_keys, in_buffer, gpg_sign_mode, ascii != 0);
+
+  *ps =
+      static_cast<GFGpgSignResult*>(GFAllocateMemory(sizeof(GFGpgSignResult)));
+  auto* s = *ps;
+
+  if (GpgFrontend::CheckGpgError(err) != GPG_ERR_NO_ERROR) {
+    s->error_string = GFStrDup(GpgFrontend::DescribeGpgErrCode(err).second);
+    return -1;
+  }
+
+  auto result =
+      GpgFrontend::ExtractParams<GpgFrontend::GpgSignResult>(data_object, 0);
+  auto out_buffer =
+      GpgFrontend::ExtractParams<GpgFrontend::GFBuffer>(data_object, 1);
+
+  auto capsule_id =
+      GpgFrontend::UI::UIModuleManager::GetInstance().MakeCapsule(result);
+
+  s->signature = GFStrDup(out_buffer.ConvertToQByteArray());
+  s->hash_algo = GFStrDup(result.HashAlgo());
+  s->capsule_id = GFStrDup(capsule_id);
+  s->error_string = GFStrDup(GpgFrontend::DescribeGpgErrCode(err).second);
+  return 0;
+}
+
+auto GPGFRONTEND_MODULE_SDK_EXPORT GFGpgPublicKey(int channel, char* key_id,
+                                                  int ascii) -> char* {
+  auto key = GpgFrontend::GpgKeyGetter::GetInstance(channel).GetKey(
+      GFUnStrDup(key_id));
+
+  if (!key.IsGood()) return nullptr;
+
+  auto [err, buffer] =
+      GpgFrontend::GpgKeyImportExporter::GetInstance(channel).ExportKey(
+          key, false, ascii != 0, true);
+
+  if (GpgFrontend::CheckGpgError(err) != GPG_ERR_NO_ERROR) return nullptr;
+
+  return GFStrDup(buffer.ConvertToQByteArray());
+}
+
+auto GPGFRONTEND_MODULE_SDK_EXPORT GFGpgKeyPrimaryUID(int channel, char* key_id,
+                                                      GFGpgKeyUID** ps) -> int {
+  auto key = GpgFrontend::GpgKeyGetter::GetInstance(channel).GetKey(
+      GFUnStrDup(key_id));
+
+  if (!key.IsGood()) return -1;
+
+  auto uids = key.GetUIDs();
+  auto& primary_uid = uids->front();
+
+  *ps = static_cast<GFGpgKeyUID*>(GFAllocateMemory(sizeof(GFGpgKeyUID)));
+
+  auto* s = *ps;
+  s->name = GFStrDup(primary_uid.GetName());
+  s->email = GFStrDup(primary_uid.GetEmail());
+  s->comment = GFStrDup(primary_uid.GetComment());
+  return 0;
+}
+
+auto GPGFRONTEND_MODULE_SDK_EXPORT
+GFGpgEncryptData(int channel, char** key_ids, int key_ids_size, char* data,
+                 int ascii, GFGpgEncryptionResult** ps) -> int {
+  auto encrypt_key_ids = CharArrayToQList(key_ids, key_ids_size);
+
+  GpgFrontend::KeyArgsList encrypt_keys;
+  for (const auto& encrypt_key_id : encrypt_key_ids) {
+    auto key =
+        GpgFrontend::GpgKeyGetter::GetInstance(channel).GetKey(encrypt_key_id);
+    if (key.IsGood()) encrypt_keys.push_back(key);
+  }
+
+  if (encrypt_keys.empty()) return -1;
+
+  auto in_buffer = GpgFrontend::GFBuffer(GFUnStrDup(data).toUtf8());
+
+  auto [err, data_object] =
+      GpgFrontend::GpgBasicOperator::GetInstance(channel).EncryptSync(
+          encrypt_keys, in_buffer, ascii != 0);
+
+  *ps = static_cast<GFGpgEncryptionResult*>(
+      GFAllocateMemory(sizeof(GFGpgEncryptionResult)));
+  auto* s = *ps;
+
+  if (GpgFrontend::CheckGpgError(err) != GPG_ERR_NO_ERROR) {
+    s->error_string = GFStrDup(GpgFrontend::DescribeGpgErrCode(err).second);
+    return -1;
+  }
+
+  auto result =
+      GpgFrontend::ExtractParams<GpgFrontend::GpgEncryptResult>(data_object, 0);
+  auto out_buffer =
+      GpgFrontend::ExtractParams<GpgFrontend::GFBuffer>(data_object, 1);
+
+  auto capsule_id =
+      GpgFrontend::UI::UIModuleManager::GetInstance().MakeCapsule(result);
+
+  s->encrypted_data = GFStrDup(out_buffer.ConvertToQByteArray());
+  s->capsule_id = GFStrDup(capsule_id);
+  s->error_string = GFStrDup(GpgFrontend::DescribeGpgErrCode(err).second);
+  return 0;
+}
+
+auto GPGFRONTEND_MODULE_SDK_EXPORT
+GFGpgDecryptData(int channel, char* data, GFGpgDecryptResult** ps) -> int {
+  auto in_buffer = GpgFrontend::GFBuffer(GFUnStrDup(data).toUtf8());
+
+  auto [err, data_object] =
+      GpgFrontend::GpgBasicOperator::GetInstance(channel).DecryptSync(
+          in_buffer);
+
+  *ps = static_cast<GFGpgDecryptResult*>(
+      GFAllocateMemory(sizeof(GFGpgDecryptResult)));
+  auto* s = *ps;
+
+  if (GpgFrontend::CheckGpgError(err) != GPG_ERR_NO_ERROR) {
+    s->error_string = GFStrDup(GpgFrontend::DescribeGpgErrCode(err).second);
+    return -1;
+  }
+
+  auto result =
+      GpgFrontend::ExtractParams<GpgFrontend::GpgDecryptResult>(data_object, 0);
+  auto out_buffer =
+      GpgFrontend::ExtractParams<GpgFrontend::GFBuffer>(data_object, 1);
+
+  auto capsule_id =
+      GpgFrontend::UI::UIModuleManager::GetInstance().MakeCapsule(result);
+
+  s->decrypted_data = GFStrDup(out_buffer.ConvertToQByteArray());
+  s->capsule_id = GFStrDup(capsule_id);
+  s->error_string = GFStrDup(GpgFrontend::DescribeGpgErrCode(err).second);
+  return 0;
+}
+
+auto GPGFRONTEND_MODULE_SDK_EXPORT GFGpgVerifyData(
+    int channel, char* data, char* signature, GFGpgVerifyResult** ps) -> int {
+  auto in_buffer = GpgFrontend::GFBuffer(GFUnStrDup(data).toUtf8());
+  auto sig_buffer = GpgFrontend::GFBuffer(GFUnStrDup(signature).toUtf8());
+
+  auto [err, data_object] =
+      GpgFrontend::GpgBasicOperator::GetInstance(channel).VerifySync(
+          in_buffer, sig_buffer);
+
+  *ps = static_cast<GFGpgVerifyResult*>(
+      GFAllocateMemory(sizeof(GFGpgVerifyResult)));
+  auto* s = *ps;
+
+  if (GpgFrontend::CheckGpgError(err) != GPG_ERR_NO_ERROR) {
+    s->error_string = GFStrDup(GpgFrontend::DescribeGpgErrCode(err).second);
+    return -1;
+  }
+
+  if (GpgFrontend::CheckGpgError(err) != GPG_ERR_NO_ERROR) return -1;
+
+  auto result =
+      GpgFrontend::ExtractParams<GpgFrontend::GpgVerifyResult>(data_object, 0);
+
+  auto capsule_id =
+      GpgFrontend::UI::UIModuleManager::GetInstance().MakeCapsule(result);
+
+  s->capsule_id = GFStrDup(capsule_id);
+  s->error_string = GFStrDup(GpgFrontend::DescribeGpgErrCode(err).second);
+  return 0;
+}