Merge pull request #126 from saturneric/dev/2.1.1/main

Develop 2.1.2.1

1 files changed, 109 insertions, 77 deletions

diff --git a/src/core/function/KeyPackageOperator.cpp b/src/core/function/KeyPackageOperator.cpp
index 5c917ab8..d185b0ef 100644
--- a/src/core/function/KeyPackageOperator.cpp
+++ b/src/core/function/KeyPackageOperator.cpp
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2021 Saturneric
+ * Copyright (C) 2021 Saturneric <[email protected]>
  *
  * This file is part of GpgFrontend.
  *
@@ -20,7 +20,7 @@
  * the gpg4usb project, which is under GPL-3.0-or-later.
  *
  * All the source code of GpgFrontend was modified and released by
- * Saturneric<[email protected]> starting on May 12, 2021.
+ * Saturneric <[email protected]> starting on May 12, 2021.
  *
  * SPDX-License-Identifier: GPL-3.0-or-later
  *
@@ -28,92 +28,124 @@
 
 #include "KeyPackageOperator.h"
 
-#include "FileOperator.h"
-#include "function/PassphraseGenerator.h"
-#include "function/gpg/GpgKeyGetter.h"
-#include "function/gpg/GpgKeyImportExporter.h"
-#include "qt-aes/qaesencryption.h"
+#include <qt-aes/qaesencryption.h>
+
+#include "core/function/KeyPackageOperator.h"
+#include "core/function/PassphraseGenerator.h"
+#include "core/function/gpg/GpgKeyImportExporter.h"
+#include "core/model/GpgImportInformation.h"
+#include "core/typedef/CoreTypedef.h"
+#include "core/utils/AsyncUtils.h"
+#include "core/utils/GpgUtils.h"
+#include "core/utils/IOUtils.h"
 
 namespace GpgFrontend {
 
-bool KeyPackageOperator::GeneratePassphrase(
-    const std::filesystem::path& phrase_path, std::string& phrase) {
+auto KeyPackageOperator::GeneratePassphrase(const QString& phrase_path,
+                                            QString& phrase) -> bool {
   phrase = PassphraseGenerator::GetInstance().Generate(256);
-  SPDLOG_DEBUG("generated passphrase: {} bytes", phrase.size());
-  return FileOperator::WriteFileStd(phrase_path, phrase);
+  GF_CORE_LOG_DEBUG("generated passphrase: {} bytes", phrase.size());
+  return WriteFile(phrase_path, phrase.toUtf8());
 }
 
-bool KeyPackageOperator::GenerateKeyPackage(
-    const std::filesystem::path& key_package_path,
-    const std::string& key_package_name, KeyIdArgsListPtr& key_ids,
-    std::string& phrase, bool secret) {
-  SPDLOG_DEBUG("generating key package: {}", key_package_name);
-
-  ByteArrayPtr key_export_data = nullptr;
-  if (!GpgKeyImportExporter::GetInstance().ExportAllKeys(
-          key_ids, key_export_data, secret)) {
-    SPDLOG_ERROR("failed to export keys");
-    return false;
-  }
-
-  auto key = QByteArray::fromStdString(phrase);
-  auto data = QString::fromStdString(*key_export_data).toLocal8Bit().toBase64();
-
-  auto hash_key = QCryptographicHash::hash(key, QCryptographicHash::Sha256);
-  QAESEncryption encryption(QAESEncryption::AES_256, QAESEncryption::ECB,
-                            QAESEncryption::Padding::ISO);
-  auto encoded = encryption.encode(data, hash_key);
-
-  SPDLOG_DEBUG("writing key package: {}", key_package_name);
-  return FileOperator::WriteFileStd(key_package_path, encoded.toStdString());
+void KeyPackageOperator::GenerateKeyPackage(const QString& key_package_path,
+                                            const QString& key_package_name,
+                                            const KeyArgsList& keys,
+                                            QString& phrase, bool secret,
+                                            const OperationCallback& cb) {
+  GF_CORE_LOG_DEBUG("generating key package: {}", key_package_name);
+
+  GpgKeyImportExporter::GetInstance().ExportAllKeys(
+      keys, secret, true, [=](GpgError err, const DataObjectPtr& data_obj) {
+        if (CheckGpgError(err) != GPG_ERR_NO_ERROR) {
+          GF_LOG_ERROR("export keys error, reason: {}",
+                       DescribeGpgErrCode(err).second);
+          cb(-1, data_obj);
+          return;
+        }
+
+        if (CheckGpgError(err) == GPG_ERR_USER_1 || data_obj == nullptr ||
+            !data_obj->Check<GFBuffer>()) {
+          cb(-1, data_obj);
+          return;
+        }
+
+        auto gf_buffer = ExtractParams<GFBuffer>(data_obj, 0);
+
+        auto data = gf_buffer.ConvertToQByteArray().toBase64();
+        auto hash_key = QCryptographicHash::hash(phrase.toUtf8(),
+                                                 QCryptographicHash::Sha256);
+        QAESEncryption encryption(QAESEncryption::AES_256, QAESEncryption::ECB,
+                                  QAESEncryption::Padding::ISO);
+        auto encoded_data = encryption.encode(data, hash_key);
+        GF_CORE_LOG_DEBUG("writing key package, name: {}", key_package_name);
+
+        cb(WriteFile(key_package_path, encoded_data) ? 0 : -1,
+           TransferParams());
+        return;
+      });
 }
 
-bool KeyPackageOperator::ImportKeyPackage(
-    const std::filesystem::path& key_package_path,
-    const std::filesystem::path& phrase_path,
-    GpgFrontend::GpgImportInformation& import_info) {
-  SPDLOG_DEBUG("importing key package: {]", key_package_path.u8string());
-
-  std::string encrypted_data;
-  FileOperator::ReadFileStd(key_package_path, encrypted_data);
-
-  if (encrypted_data.empty()) {
-    SPDLOG_ERROR("failed to read key package: {}", key_package_path.u8string());
-    return false;
-  };
-
-  std::string passphrase;
-  FileOperator::ReadFileStd(phrase_path, passphrase);
-  SPDLOG_DEBUG("passphrase: {} bytes", passphrase.size());
-  if (passphrase.size() != 256) {
-    SPDLOG_ERROR("failed to read passphrase: {}", phrase_path.u8string());
-    return false;
-  }
-
-  auto hash_key = QCryptographicHash::hash(
-      QByteArray::fromStdString(passphrase), QCryptographicHash::Sha256);
-  auto encoded = QByteArray::fromStdString(encrypted_data);
-
-  QAESEncryption encryption(QAESEncryption::AES_256, QAESEncryption::ECB,
-                            QAESEncryption::Padding::ISO);
-
-  auto decoded = encryption.removePadding(encryption.decode(encoded, hash_key));
-  auto key_data = QByteArray::fromBase64(decoded);
-
-  SPDLOG_DEBUG("key data size: {}", key_data.size());
-  if (!key_data.startsWith(GpgConstants::PGP_PUBLIC_KEY_BEGIN) &&
-      !key_data.startsWith(GpgConstants::PGP_PRIVATE_KEY_BEGIN)) {
-    return false;
-  }
-
-  auto key_data_ptr = std::make_unique<ByteArray>(key_data.toStdString());
-  import_info =
-      GpgKeyImportExporter::GetInstance().ImportKey(std::move(key_data_ptr));
-  return true;
+void KeyPackageOperator::ImportKeyPackage(const QString& key_package_path,
+                                          const QString& phrase_path,
+                                          const OperationCallback& cb) {
+  RunOperaAsync(
+      [=](const DataObjectPtr& data_object) -> GFError {
+        GF_CORE_LOG_DEBUG("importing key package: {}", key_package_path);
+
+        QByteArray encrypted_data;
+        ReadFile(key_package_path, encrypted_data);
+
+        if (encrypted_data.isEmpty()) {
+          GF_CORE_LOG_ERROR("failed to read key package: {}", key_package_path);
+          return -1;
+        };
+
+        QByteArray passphrase;
+        ReadFile(phrase_path, passphrase);
+        if (passphrase.size() != 256) {
+          GF_CORE_LOG_ERROR("passphrase size mismatch: {}", phrase_path);
+          return -1;
+        }
+
+        auto hash_key =
+            QCryptographicHash::hash(passphrase, QCryptographicHash::Sha256);
+        auto encoded = encrypted_data;
+
+        QAESEncryption encryption(QAESEncryption::AES_256, QAESEncryption::ECB,
+                                  QAESEncryption::Padding::ISO);
+
+        auto decoded =
+            encryption.removePadding(encryption.decode(encoded, hash_key));
+        auto key_data = QByteArray::fromBase64(decoded);
+        if (!key_data.startsWith(PGP_PUBLIC_KEY_BEGIN) &&
+            !key_data.startsWith(PGP_PRIVATE_KEY_BEGIN)) {
+          return -1;
+        }
+
+        auto import_info_ptr =
+            GpgKeyImportExporter::GetInstance().ImportKey(GFBuffer(key_data));
+        if (import_info_ptr == nullptr) return GPG_ERR_NO_DATA;
+
+        auto import_info = *import_info_ptr;
+        data_object->Swap({import_info});
+        return 0;
+      },
+      cb, "import_key_package");
 }
 
-std::string KeyPackageOperator::GenerateKeyPackageName() {
+auto KeyPackageOperator::GenerateKeyPackageName() -> QString {
   return generate_key_package_name();
 }
 
+/**
+ * @brief generate key package name
+ *
+ * @return QString key package name
+ */
+auto KeyPackageOperator::generate_key_package_name() -> QString {
+  return QString("KeyPackage_%1")
+      .arg(QRandomGenerator::global()->bounded(999, 99999));
+}
+
 }  // namespace GpgFrontend