diff options
Diffstat (limited to 'src/core/function')
25 files changed, 690 insertions, 1170 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/GlobalSettingStation.cpp b/src/core/function/GlobalSettingStation.cpp index 4c88fde4..62b24331 100644 --- a/src/core/function/GlobalSettingStation.cpp +++ b/src/core/function/GlobalSettingStation.cpp @@ -48,7 +48,7 @@ class GlobalSettingStation::Impl { Module::UpsertRTValue("core", "env.state.portable", 1); LOG_I() << "GpgFrontend runs in the portable mode now"; - app_data_path_ = app_path_ + "/../"; + app_data_path_ = QDir(app_path_ + "/../").canonicalPath(); app_config_path_ = app_data_path_ + "/config"; portable_mode_ = true; @@ -61,6 +61,11 @@ class GlobalSettingStation::Impl { #if defined(_WIN32) || defined(WIN32) LOG_I() << "app config path: " << app_config_path_; if (!QDir(app_config_path_).exists()) QDir(app_config_path_).mkpath("."); +#else + if (IsProtableMode()) { + LOG_I() << "app config path: " << app_config_path_; + if (!QDir(app_config_path_).exists()) QDir(app_config_path_).mkpath("."); + } #endif if (!QDir(app_data_path_).exists()) QDir(app_data_path_).mkpath("."); @@ -74,6 +79,7 @@ class GlobalSettingStation::Impl { #if defined(_WIN32) || defined(WIN32) return QSettings(app_config_file_path(), QSettings::IniFormat); #else + if (IsProtableMode()) return {app_config_file_path(), QSettings::IniFormat}; return QSettings(); #endif } @@ -171,6 +177,8 @@ class GlobalSettingStation::Impl { return exec_binary_path + "/modules"; } + [[nodiscard]] auto IsProtableMode() const -> bool { return portable_mode_; } + private: [[nodiscard]] auto app_config_file_path() const -> QString { return app_config_path_ + "/config.ini"; @@ -244,4 +252,11 @@ auto GlobalSettingStation::GetConfigPath() const -> QString { auto GlobalSettingStation::GetIntegratedModulePath() const -> QString { return p_->GetIntegratedModulePath(); } + +auto GlobalSettingStation::IsProtableMode() const -> bool { + return p_->IsProtableMode(); +} +auto GetSettings() -> QSettings { + return GlobalSettingStation::GetInstance().GetSettings(); +} } // namespace GpgFrontend
\ No newline at end of file diff --git a/src/core/function/GlobalSettingStation.h b/src/core/function/GlobalSettingStation.h index f45c0b49..9ef29792 100644 --- a/src/core/function/GlobalSettingStation.h +++ b/src/core/function/GlobalSettingStation.h @@ -131,8 +131,19 @@ class GPGFRONTEND_CORE_EXPORT GlobalSettingStation */ [[nodiscard]] auto GetIntegratedModulePath() const -> QString; + /** + * @brief + * + * @return true + * @return false + */ + [[nodiscard]] auto IsProtableMode() const -> bool; + private: class Impl; SecureUniquePtr<Impl> p_; }; + +auto GPGFRONTEND_CORE_EXPORT GetSettings() -> QSettings; + } // namespace GpgFrontend diff --git a/src/core/function/basic/GpgFunctionObject.h b/src/core/function/basic/GpgFunctionObject.h index 06ad6bfd..41a597e5 100644 --- a/src/core/function/basic/GpgFunctionObject.h +++ b/src/core/function/basic/GpgFunctionObject.h @@ -141,11 +141,11 @@ class SingletonFunctionObject : public ChannelObject { } /** - * @brief Get all the channel ids + * @brief Get the All Channel Id object * - * @return std::vector<int> + * @return QContainer<int> */ - static auto GetAllChannelId() -> std::vector<int> { + static auto GetAllChannelId() -> QContainer<int> { return SingletonStorageCollection::GetInstance(false) ->GetSingletonStorage(typeid(T)) ->GetAllChannelId(); diff --git a/src/core/function/basic/SingletonStorage.cpp b/src/core/function/basic/SingletonStorage.cpp index e51acd77..be26d0f5 100644 --- a/src/core/function/basic/SingletonStorage.cpp +++ b/src/core/function/basic/SingletonStorage.cpp @@ -31,7 +31,8 @@ #include <shared_mutex> #include "core/function/basic/ChannelObject.h" -#include "utils/MemoryUtils.h" +#include "core/typedef/CoreTypedef.h" +#include "core/utils/MemoryUtils.h" namespace GpgFrontend { @@ -60,8 +61,8 @@ class SingletonStorage::Impl { } } - auto GetAllChannelId() -> std::vector<int> { - std::vector<int> channels; + auto GetAllChannelId() -> QContainer<int> { + QContainer<int> channels; channels.reserve(instances_map_.size()); for (const auto& [key, value] : instances_map_) { channels.push_back(key); @@ -119,7 +120,7 @@ auto SingletonStorage::FindObjectInChannel(int channel) return p_->FindObjectInChannel(channel); } -auto SingletonStorage::GetAllChannelId() -> std::vector<int> { +auto SingletonStorage::GetAllChannelId() -> QContainer<int> { return p_->GetAllChannelId(); } diff --git a/src/core/function/basic/SingletonStorage.h b/src/core/function/basic/SingletonStorage.h index 81ae570f..574a16ec 100644 --- a/src/core/function/basic/SingletonStorage.h +++ b/src/core/function/basic/SingletonStorage.h @@ -29,6 +29,7 @@ #pragma once #include "core/function/SecureMemoryAllocator.h" +#include "core/typedef/GpgTypedef.h" namespace GpgFrontend { @@ -66,11 +67,11 @@ class GPGFRONTEND_CORE_EXPORT SingletonStorage { auto FindObjectInChannel(int channel) -> ChannelObject*; /** - * @brief Get all the channel ids + * @brief Get the All Channel Id object * - * @return std::vector<int> + * @return QContainer<int> */ - auto GetAllChannelId() -> std::vector<int>; + auto GetAllChannelId() -> QContainer<int>; /** * @brief Set a new object in channel object diff --git a/src/core/function/gpg/GpgAdvancedOperator.cpp b/src/core/function/gpg/GpgAdvancedOperator.cpp index 6b56d867..590110e9 100644 --- a/src/core/function/gpg/GpgAdvancedOperator.cpp +++ b/src/core/function/gpg/GpgAdvancedOperator.cpp @@ -32,211 +32,89 @@ #include "GpgAdvancedOperator.h" +#include <utility> + #include "core/function/gpg/GpgCommandExecutor.h" #include "core/module/ModuleManager.h" +#include "core/utils/GpgUtils.h" -void GpgFrontend::GpgAdvancedOperator::ClearGpgPasswordCache( - OperationCallback cb) { - const auto gpgconf_path = Module::RetrieveRTValueTypedOrDefault<>( - "core", "gpgme.ctx.gpgconf_path", QString{}); - - if (gpgconf_path.isEmpty()) { - FLOG_W("cannot get valid gpgconf path from rt, abort."); - cb(-1, TransferParams()); - return; - } +namespace GpgFrontend { -#if defined(__APPLE__) && defined(__MACH__) - FLOG_I("kill all gpg components in order to clear gpg password cache"); - KillAllGpgComponents(); -#else - GpgFrontend::GpgCommandExecutor::ExecuteSync( - {gpgconf_path, QStringList{"--reload", "gpg-agent"}, - [=](int exit_code, const QString & /*p_out*/, - const QString & /*p_err*/) { - cb(exit_code == 0 ? 0 : -1, TransferParams()); - }}); -#endif -} - -void GpgFrontend::GpgAdvancedOperator::ReloadGpgComponents( - OperationCallback cb) { +void ExecuteGpgCommand(const QString &operation, const QStringList &extra_args, + OperationCallback cb) { const auto gpgconf_path = Module::RetrieveRTValueTypedOrDefault<>( "core", "gpgme.ctx.gpgconf_path", QString{}); if (gpgconf_path.isEmpty()) { FLOG_W("cannot get valid gpgconf path from rt, abort."); - cb(-1, TransferParams()); + if (cb) cb(-1, TransferParams()); return; } - GpgFrontend::GpgCommandExecutor::ExecuteSync( - {gpgconf_path, QStringList{"--reload"}, - [=](int exit_code, const QString &, const QString &) { - FLOG_D("gpgconf reload exit code: %d", exit_code); - cb(exit_code == 0 ? 0 : -1, TransferParams()); - }}); -} - -void GpgFrontend::GpgAdvancedOperator::KillAllGpgComponents() { - const auto gpgconf_path = Module::RetrieveRTValueTypedOrDefault<>( - "core", "gpgme.ctx.gpgconf_path", QString{}); - - if (gpgconf_path.isEmpty()) { - FLOG_W("cannot get valid gpgconf path from rt, abort."); - return; + auto key_dbs = GetGpgKeyDatabaseInfos(); + auto total_tasks = static_cast<int>(key_dbs.size()); + std::atomic<int> completed_tasks{0}; + std::vector<int> results(total_tasks, 0); + + int task_index = 0; + for (const auto &key_db : key_dbs) { + const int current_index = task_index++; + const auto target_home_dir = + QDir::toNativeSeparators(QFileInfo(key_db.path).canonicalFilePath()); + + QStringList arguments = QStringList{"--homedir", target_home_dir}; + arguments.append(extra_args); + + GpgCommandExecutor::ExecuteSync( + {gpgconf_path, arguments, + [=, &completed_tasks, &results](int exit_code, const QString &, + const QString &) { + FLOG_D("%s exit code: %d", qPrintable(operation), exit_code); + + results[current_index] = exit_code; + + if (++completed_tasks == total_tasks && cb) { + int final_result = + std::all_of(results.begin(), results.end(), + [](int result) { return result >= 0; }) + ? 0 + : -1; + cb(final_result, TransferParams()); + } + }}); } - - GpgFrontend::GpgCommandExecutor::ExecuteSync( - {gpgconf_path, QStringList{"--verbose", "--kill", "all"}, - [=](int exit_code, const QString &p_out, const QString &p_err) { - bool success = true; - if (exit_code != 0) { - success = false; - LOG_W() << "gpgconf execute error, process stderr: " << p_err - << ", process stdout: " << p_out; - return; - } - - FLOG_D("gpgconf --kill --all execute result: %d", success); - }}); } -void GpgFrontend::GpgAdvancedOperator::RestartGpgComponents() { - const auto gpgconf_path = Module::RetrieveRTValueTypedOrDefault<>( - "core", "gpgme.ctx.gpgconf_path", QString{}); - - if (gpgconf_path.isEmpty()) { - FLOG_W("cannot get valid gpgconf path from rt, abort."); - return; - } - - GpgFrontend::GpgCommandExecutor::ExecuteSync( - {gpgconf_path, QStringList{"--verbose", "--kill", "all"}, - [=](int exit_code, const QString &p_out, const QString &p_err) { - FLOG_D("gpgconf --kill all command got exit code: %d", exit_code); - bool success = true; - if (exit_code != 0) { - success = false; - LOG_W() << "gpgconf execute error, process stderr: " << p_err - << ", process stdout: " << p_out; - return; - } - - FLOG_D("gpgconf --kill --all execute result: %d", success); - if (!success) { - FLOG_W("restart all component after core initalized failed"); - Module::UpsertRTValue( - "core", "gpg_advanced_operator.restart_gpg_components", false); - return; - } - -#if defined(__APPLE__) && defined(__MACH__) - FLOG_I("getting gpg-agent to start automatically on macOS"); -#else - StartGpgAgent([](int err, DataObjectPtr) { - if (err >= 0) { - Module::UpsertRTValue( - "core", "gpg_advanced_operator.restart_gpg_components", true); - return; - } - }); -#endif - }}); +void GpgAdvancedOperator::ClearGpgPasswordCache(OperationCallback cb) { + ExecuteGpgCommand("Clear GPG Password Cache", {"--reload", "gpg-agent"}, + std::move(cb)); } -void GpgFrontend::GpgAdvancedOperator::ResetConfigures(OperationCallback cb) { +void GpgAdvancedOperator::ReloadGpgComponents(OperationCallback cb) { const auto gpgconf_path = Module::RetrieveRTValueTypedOrDefault<>( "core", "gpgme.ctx.gpgconf_path", QString{}); - - if (gpgconf_path.isEmpty()) { - FLOG_W("cannot get valid gpgconf path from rt, abort."); - cb(-1, TransferParams()); - return; - } - - GpgFrontend::GpgCommandExecutor::ExecuteSync( - {gpgconf_path, QStringList{"--apply-defaults"}, - [=](int exit_code, const QString &, const QString &) { - FLOG_D("gpgconf apply-defaults exit code: %d", exit_code); - cb(exit_code == 0 ? 0 : -1, TransferParams()); - }}); + ExecuteGpgCommand("Reload GPG Components", {"--reload", "all"}, + std::move(cb)); } -void GpgFrontend::GpgAdvancedOperator::StartGpgAgent(OperationCallback cb) { - if (!Module::IsModuleActivate(kGnuPGInfoGatheringModuleID)) { - cb(-1, TransferParams()); - return; - } - - const auto gpg_agent_path = Module::RetrieveRTValueTypedOrDefault<>( - kGnuPGInfoGatheringModuleID, "gnupg.gpg_agent_path", QString{}); - - const auto home_path = Module::RetrieveRTValueTypedOrDefault<>( - kGnuPGInfoGatheringModuleID, "gnupg.home_path", QString{}); - - if (gpg_agent_path.isEmpty()) { - FLOG_W("cannot get valid gpg agent path from rt, abort."); - cb(-1, TransferParams()); - return; - } - - GpgFrontend::GpgCommandExecutor::ExecuteSync( - {gpg_agent_path, QStringList{"--homedir", home_path, "--daemon"}, - [=](int exit_code, const QString &, const QString &) { - FLOG_D("gpg-agent daemon exit code: %d", exit_code); - cb(exit_code >= 0 ? 0 : -1, TransferParams()); - }}); +void GpgAdvancedOperator::KillAllGpgComponents(OperationCallback cb) { + ExecuteGpgCommand("Kill All GPG Components", {"--kill", "all"}, + std::move(cb)); } -void GpgFrontend::GpgAdvancedOperator::StartDirmngr(OperationCallback cb) { - if (!Module::IsModuleActivate(kGnuPGInfoGatheringModuleID)) { - cb(-1, TransferParams()); - return; - } - - const auto dirmngr_path = Module::RetrieveRTValueTypedOrDefault<>( - kGnuPGInfoGatheringModuleID, "gnupg.dirmngr_path", QString{}); - - const auto home_path = Module::RetrieveRTValueTypedOrDefault<>( - kGnuPGInfoGatheringModuleID, "gnupg.home_path", QString{}); - - if (dirmngr_path.isEmpty()) { - FLOG_W("cannot get valid dirmngr path from rt, abort."); - cb(-1, TransferParams()); - return; - } - - GpgFrontend::GpgCommandExecutor::ExecuteSync( - {dirmngr_path, QStringList{"--homedir", home_path, "--daemon"}, - [=](int exit_code, const QString &, const QString &) { - FLOG_D("gpgconf daemon exit code: %d", exit_code); - cb(exit_code >= 0 ? 0 : -1, TransferParams()); - }}); +void GpgAdvancedOperator::ResetConfigures(OperationCallback cb) { + ExecuteGpgCommand("Reset Gnupg Configures", {"--apply-defaults"}, + std::move(cb)); } -void GpgFrontend::GpgAdvancedOperator::StartKeyBoxd(OperationCallback cb) { - if (!Module::IsModuleActivate(kGnuPGInfoGatheringModuleID)) { - cb(-1, TransferParams()); - return; - } - - const auto keyboxd_path = Module::RetrieveRTValueTypedOrDefault<>( - kGnuPGInfoGatheringModuleID, "gnupg.keyboxd_path", QString{}); - - const auto home_path = Module::RetrieveRTValueTypedOrDefault<>( - kGnuPGInfoGatheringModuleID, "gnupg.home_path", QString{}); - - if (keyboxd_path.isEmpty()) { - FLOG_W("cannot get valid keyboxd path from rt, abort."); - cb(-1, TransferParams()); - return; - } +void GpgAdvancedOperator::LaunchGpgComponents(OperationCallback cb) { + ExecuteGpgCommand("Launch All GPG Components", {"--launch", "all"}, + std::move(cb)); +} - GpgFrontend::GpgCommandExecutor::ExecuteSync( - {keyboxd_path, QStringList{"--homedir", home_path, "--daemon"}, - [=](int exit_code, const QString &, const QString &) { - FLOG_D("gpgconf daemon exit code: %d", exit_code); - cb(exit_code >= 0 ? 0 : -1, TransferParams()); - }}); +void GpgAdvancedOperator::RestartGpgComponents(OperationCallback cb) { + KillAllGpgComponents(nullptr); + LaunchGpgComponents(std::move(cb)); } + +} // namespace GpgFrontend
\ No newline at end of file diff --git a/src/core/function/gpg/GpgAdvancedOperator.h b/src/core/function/gpg/GpgAdvancedOperator.h index 1be2c2e4..cfd5fbcf 100644 --- a/src/core/function/gpg/GpgAdvancedOperator.h +++ b/src/core/function/gpg/GpgAdvancedOperator.h @@ -60,7 +60,7 @@ class GPGFRONTEND_CORE_EXPORT GpgAdvancedOperator { * @return true * @return false */ - static void RestartGpgComponents(); + static void RestartGpgComponents(OperationCallback); /** * @brief @@ -76,29 +76,13 @@ class GPGFRONTEND_CORE_EXPORT GpgAdvancedOperator { * @return true * @return false */ - static void StartGpgAgent(OperationCallback); - - /** - * @brief - * - * @return true - * @return false - */ - static void StartDirmngr(OperationCallback); - - /** - * @brief - * - * @return true - * @return false - */ - static void StartKeyBoxd(OperationCallback); + static void LaunchGpgComponents(OperationCallback); /** * @brief * */ - static void KillAllGpgComponents(); + static void KillAllGpgComponents(OperationCallback); }; } // namespace GpgFrontend diff --git a/src/core/function/gpg/GpgBasicOperator.cpp b/src/core/function/gpg/GpgBasicOperator.cpp index 6443f242..7f36e60a 100644 --- a/src/core/function/gpg/GpgBasicOperator.cpp +++ b/src/core/function/gpg/GpgBasicOperator.cpp @@ -43,29 +43,49 @@ 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(); - std::vector<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.IsHasActualSignCap()) { + 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"); + } +} - GpgData data_in(in_buffer); - GpgData data_out; +auto EncryptImpl(GpgContext& ctx_, const KeyArgsList& keys, + const GFBuffer& in_buffer, bool ascii, + const DataObjectPtr& data_object) -> GpgError { + auto recipients = Convert2RawGpgMEKeyList(keys); - 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; - return err; + 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)), + data_out.Read2GFBuffer(), + }); + + 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,25 +94,8 @@ 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; - - std::vector<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_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; + [=](const DataObjectPtr& data_object) { + return EncryptImpl(ctx_, keys, in_buffer, ascii, data_object); }, "gpgme_op_encrypt", "2.1.0"); } @@ -100,17 +103,8 @@ auto GpgBasicOperator::EncryptSync(const KeyArgsList& keys, 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 EncryptImpl(ctx_, {}, in_buffer, ascii, data_object); }, cb, "gpgme_op_encrypt_symmetric", "2.1.0"); } @@ -119,35 +113,32 @@ 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 EncryptImpl(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 +146,43 @@ 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())), + GFBuffer(), + }); + + 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 +191,41 @@ 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 +234,36 @@ 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 +272,37 @@ 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 +311,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; - std::vector<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,57 +323,24 @@ 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; - std::vector<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) -> std::unique_ptr<KeyArgsList> { +auto GpgBasicOperator::GetSigners(bool ascii) -> KeyArgsList { auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext(); auto count = gpgme_signers_count(ctx); - auto signers = std::make_unique<std::vector<GpgKey>>(); + auto signers = KeyArgsList{}; for (auto i = 0U; i < count; i++) { auto key = GpgKey(gpgme_signers_enum(ctx, i)); - signers->push_back(GpgKey(std::move(key))); + signers.push_back(GpgKey(std::move(key))); } return signers; } diff --git a/src/core/function/gpg/GpgBasicOperator.h b/src/core/function/gpg/GpgBasicOperator.h index 431ccf1c..990d7af5 100644 --- a/src/core/function/gpg/GpgBasicOperator.h +++ b/src/core/function/gpg/GpgBasicOperator.h @@ -226,7 +226,7 @@ class GPGFRONTEND_CORE_EXPORT GpgBasicOperator * * @return Intelligent pointer pointing to the private key list */ - auto GetSigners(bool ascii) -> std::unique_ptr<KeyArgsList>; + auto GetSigners(bool ascii) -> KeyArgsList; private: GpgContext& ctx_ = GpgContext::GetInstance( diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp index 3e218b92..5256de60 100644 --- a/src/core/function/gpg/GpgCommandExecutor.cpp +++ b/src/core/function/gpg/GpgCommandExecutor.cpp @@ -45,8 +45,8 @@ auto BuildTaskFromExecCtx(const GpgCommandExecutor::ExecuteContext &context) Thread::Task::TaskCallback result_callback = [cmd](int /*rtn*/, const DataObjectPtr &data_object) { - FLOG_D("data object args count of cmd executor result callback: %ld", - data_object->GetObjectSize()); + LOG_D() << "data object args count of cmd executor result callback:" + << data_object->GetObjectSize(); if (!data_object->Check<int, QString, GpgCommandExecutorCallback>()) { FLOG_W("data object checking failed"); diff --git a/src/core/function/gpg/GpgFileOpera.cpp b/src/core/function/gpg/GpgFileOpera.cpp index 5d29364b..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 { - std::vector<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 { - std::vector<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 { - std::vector<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; - std::vector<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; - std::vector<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; - std::vector<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,73 +433,45 @@ 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"); } -void GpgFileOpera::EncryptDerectorySymmetric(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::EncryptDerectorySymmetricSync( +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 939ddc2d..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 { @@ -123,7 +123,7 @@ class GPGFRONTEND_CORE_EXPORT GpgFileOpera * @param out_path * @param cb */ - void EncryptDerectorySymmetric(const QString& in_path, bool ascii, + void EncryptDirectorySymmetric(const QString& in_path, bool ascii, const QString& out_path, const GpgOperationCallback& cb); @@ -134,7 +134,7 @@ class GPGFRONTEND_CORE_EXPORT GpgFileOpera * @param ascii * @param out_path */ - auto EncryptDerectorySymmetricSync(const QString& in_path, bool ascii, + auto EncryptDirectorySymmetricSync(const QString& in_path, bool ascii, const QString& out_path) -> std::tuple<GpgError, DataObjectPtr>; @@ -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/function/gpg/GpgKeyGetter.cpp b/src/core/function/gpg/GpgKeyGetter.cpp index c4526e49..e5b234f8 100644 --- a/src/core/function/gpg/GpgKeyGetter.cpp +++ b/src/core/function/gpg/GpgKeyGetter.cpp @@ -73,17 +73,17 @@ class GpgKeyGetter::Impl : public SingletonFunctionObject<GpgKeyGetter::Impl> { return GpgKey(std::move(p_key)); } - auto FetchKey() -> KeyLinkListPtr { + auto FetchKey() -> GpgKeyList { if (keys_search_cache_.empty()) { FlushKeyCache(); } - auto keys_list = std::make_unique<GpgKeyLinkList>(); + auto keys_list = GpgKeyList{}; { // get the lock std::lock_guard<std::mutex> lock(keys_cache_mutex_); for (const auto& key : keys_cache_) { - keys_list->push_back(key); + keys_list.push_back(key); } } return keys_list; @@ -149,25 +149,17 @@ class GpgKeyGetter::Impl : public SingletonFunctionObject<GpgKeyGetter::Impl> { return true; } - auto GetKeys(const KeyIdArgsListPtr& ids) -> KeyListPtr { - auto keys = std::make_unique<KeyArgsList>(); - for (const auto& key_id : *ids) keys->emplace_back(GetKey(key_id, true)); + auto GetKeys(const KeyIdArgsList& ids) -> GpgKeyList { + auto keys = GpgKeyList{}; + for (const auto& key_id : ids) keys.emplace_back(GetKey(key_id, true)); return keys; } - auto GetKeysCopy(const KeyLinkListPtr& keys) -> KeyLinkListPtr { - // get the lock - std::lock_guard<std::mutex> lock(ctx_mutex_); - auto keys_copy = std::make_unique<GpgKeyLinkList>(); - for (const auto& key : *keys) keys_copy->emplace_back(key); - return keys_copy; - } - - auto GetKeysCopy(const KeyListPtr& keys) -> KeyListPtr { + auto GetKeysCopy(const GpgKeyList& keys) -> GpgKeyList { // get the lock std::lock_guard<std::mutex> lock(ctx_mutex_); - auto keys_copy = std::make_unique<KeyArgsList>(); - for (const auto& key : *keys) keys_copy->emplace_back(key); + auto keys_copy = GpgKeyList{}; + for (const auto& key : keys) keys_copy.emplace_back(key); return keys_copy; } @@ -243,19 +235,15 @@ auto GpgKeyGetter::GetPubkey(const QString& key_id, bool use_cache) -> GpgKey { auto GpgKeyGetter::FlushKeyCache() -> bool { return p_->FlushKeyCache(); } -auto GpgKeyGetter::GetKeys(const KeyIdArgsListPtr& ids) -> KeyListPtr { +auto GpgKeyGetter::GetKeys(const KeyIdArgsList& ids) -> GpgKeyList { return p_->GetKeys(ids); } -auto GpgKeyGetter::GetKeysCopy(const KeyLinkListPtr& keys) -> KeyLinkListPtr { - return p_->GetKeysCopy(keys); -} - -auto GpgKeyGetter::GetKeysCopy(const KeyListPtr& keys) -> KeyListPtr { +auto GpgKeyGetter::GetKeysCopy(const GpgKeyList& keys) -> GpgKeyList { return p_->GetKeysCopy(keys); } -auto GpgKeyGetter::FetchKey() -> KeyLinkListPtr { return p_->FetchKey(); } +auto GpgKeyGetter::FetchKey() -> GpgKeyList { return p_->FetchKey(); } auto GpgKeyGetter::GetGpgKeyTableModel() -> QSharedPointer<GpgKeyTableModel> { return p_->GetGpgKeyTableModel(); diff --git a/src/core/function/gpg/GpgKeyGetter.h b/src/core/function/gpg/GpgKeyGetter.h index f354ff49..2ed34531 100644 --- a/src/core/function/gpg/GpgKeyGetter.h +++ b/src/core/function/gpg/GpgKeyGetter.h @@ -68,7 +68,7 @@ class GPGFRONTEND_CORE_EXPORT GpgKeyGetter * @param ids * @return KeyListPtr */ - auto GetKeys(const KeyIdArgsListPtr& key_ids) -> KeyListPtr; + auto GetKeys(const KeyIdArgsList& key_ids) -> GpgKeyList; /** * @brief Get the Pubkey object @@ -83,7 +83,7 @@ class GPGFRONTEND_CORE_EXPORT GpgKeyGetter * * @return KeyLinkListPtr */ - auto FetchKey() -> KeyLinkListPtr; + auto FetchKey() -> GpgKeyList; /** * @brief flush the keys in the cache @@ -97,15 +97,7 @@ class GPGFRONTEND_CORE_EXPORT GpgKeyGetter * @param keys * @return KeyListPtr */ - auto GetKeysCopy(const KeyListPtr& keys) -> KeyListPtr; - - /** - * @brief Get the Keys Copy object - * - * @param keys - * @return KeyLinkListPtr - */ - auto GetKeysCopy(const KeyLinkListPtr& keys) -> KeyLinkListPtr; + auto GetKeysCopy(const GpgKeyList& keys) -> GpgKeyList; /** * @brief diff --git a/src/core/function/gpg/GpgKeyImportExporter.cpp b/src/core/function/gpg/GpgKeyImportExporter.cpp index fa1f908f..6c78f760 100644 --- a/src/core/function/gpg/GpgKeyImportExporter.cpp +++ b/src/core/function/gpg/GpgKeyImportExporter.cpp @@ -82,7 +82,7 @@ auto GpgKeyImportExporter::ExportKey(const GpgKey& key, bool secret, bool ascii, if (shortest) mode |= GPGME_EXPORT_MODE_MINIMAL; if (ssh_mode) mode |= GPGME_EXPORT_MODE_SSH; - std::vector<gpgme_key_t> keys_array; + QContainer<gpgme_key_t> keys_array; // Last entry data_in array has to be nullptr keys_array.emplace_back(key); @@ -114,7 +114,7 @@ void GpgKeyImportExporter::ExportKeys(const KeyArgsList& keys, bool secret, if (shortest) mode |= GPGME_EXPORT_MODE_MINIMAL; if (ssh_mode) mode |= GPGME_EXPORT_MODE_SSH; - std::vector<gpgme_key_t> keys_array(keys.begin(), keys.end()); + QContainer<gpgme_key_t> keys_array(keys.begin(), keys.end()); // Last entry data_in array has to be nullptr keys_array.emplace_back(nullptr); @@ -144,7 +144,7 @@ void GpgKeyImportExporter::ExportAllKeys(const KeyArgsList& keys, bool secret, if (keys.empty()) return GPG_ERR_CANCELED; int mode = 0; - std::vector<gpgme_key_t> keys_array(keys.begin(), keys.end()); + QContainer<gpgme_key_t> keys_array(keys.begin(), keys.end()); // Last entry data_in array has to be nullptr keys_array.emplace_back(nullptr); diff --git a/src/core/function/gpg/GpgKeyManager.cpp b/src/core/function/gpg/GpgKeyManager.cpp index d0576e59..afa775eb 100644 --- a/src/core/function/gpg/GpgKeyManager.cpp +++ b/src/core/function/gpg/GpgKeyManager.cpp @@ -61,10 +61,10 @@ auto GpgKeyManager::SignKey(const GpgKey& target, KeyArgsList& keys, } auto GpgKeyManager::RevSign(const GpgKey& key, - const SignIdArgsListPtr& signature_id) -> bool { + const SignIdArgsList& signature_id) -> bool { auto& key_getter = GpgKeyGetter::GetInstance(GetChannel()); - for (const auto& sign_id : *signature_id) { + for (const auto& sign_id : signature_id) { auto signing_key = key_getter.GetKey(sign_id.first); assert(signing_key.IsGood()); @@ -271,13 +271,8 @@ auto GpgKeyManager::RevokeSubkey(const GpgKey& key, int subkey_index, } // dealing with reason text -#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 4) - auto reason_text_lines = SecureCreateSharedObject<QList<QString>>( + auto reason_text_lines = SecureCreateSharedObject<QStringList>( reason_text.split('\n', Qt::SkipEmptyParts).toVector()); -#else - auto reason_text_lines = SecureCreateSharedObject<QVector<QString>>( - reason_text.split('\n', Qt::SkipEmptyParts).toVector()); -#endif AutomatonNextStateHandler next_state_handler = [](AutomatonState state, QString status, QString args) { diff --git a/src/core/function/gpg/GpgKeyManager.h b/src/core/function/gpg/GpgKeyManager.h index 7bd45a1c..817179e1 100644 --- a/src/core/function/gpg/GpgKeyManager.h +++ b/src/core/function/gpg/GpgKeyManager.h @@ -68,7 +68,7 @@ class GPGFRONTEND_CORE_EXPORT GpgKeyManager * @return false */ auto RevSign(const GpgFrontend::GpgKey& key, - const GpgFrontend::SignIdArgsListPtr& signature_id) -> bool; + const GpgFrontend::SignIdArgsList& signature_id) -> bool; /** * @brief Set the Expire object diff --git a/src/core/function/gpg/GpgKeyOpera.cpp b/src/core/function/gpg/GpgKeyOpera.cpp index a5346655..23a848ee 100644 --- a/src/core/function/gpg/GpgKeyOpera.cpp +++ b/src/core/function/gpg/GpgKeyOpera.cpp @@ -28,14 +28,12 @@ #include "GpgKeyOpera.h" -#include <gpg-error.h> - #include "core/GpgModel.h" #include "core/function/gpg/GpgCommandExecutor.h" #include "core/function/gpg/GpgKeyGetter.h" #include "core/model/DataObject.h" -#include "core/model/GpgGenKeyInfo.h" #include "core/model/GpgGenerateKeyResult.h" +#include "core/model/GpgKeyGenerateInfo.h" #include "core/module/ModuleManager.h" #include "core/typedef/GpgTypedef.h" #include "core/utils/AsyncUtils.h" @@ -51,9 +49,9 @@ GpgKeyOpera::GpgKeyOpera(int channel) * Delete keys * @param uidList key ids */ -void GpgKeyOpera::DeleteKeys(KeyIdArgsListPtr key_ids) { +void GpgKeyOpera::DeleteKeys(KeyIdArgsList key_ids) { GpgError err; - for (const auto& tmp : *key_ids) { + for (const auto& tmp : key_ids) { auto key = GpgKeyGetter::GetInstance(GetChannel()).GetKey(tmp); if (key.IsGood()) { err = CheckGpgError(gpgme_op_delete_ext( @@ -112,15 +110,8 @@ void GpgKeyOpera::GenerateRevokeCert(const GpgKey& key, << "text:" << revocation_reason_text; // dealing with reason text -#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 4) - auto reason_text_lines = - GpgFrontend::SecureCreateSharedObject<QList<QString>>( - revocation_reason_text.split('\n', Qt::SkipEmptyParts).toVector()); -#else - auto reason_text_lines = - GpgFrontend::SecureCreateSharedObject<QVector<QString>>( - revocation_reason_text.split('\n', Qt::SkipEmptyParts).toVector()); -#endif + auto reason_text_lines = GpgFrontend::SecureCreateSharedObject<QStringList>( + revocation_reason_text.split('\n', Qt::SkipEmptyParts).toVector()); const auto app_path = Module::RetrieveRTValueTypedOrDefault<>( "core", "gpgme.ctx.app_path", QString{}); @@ -170,337 +161,174 @@ void GpgKeyOpera::GenerateRevokeCert(const GpgKey& key, }}); } +auto GenerateKeyImpl(GpgContext& ctx, + const QSharedPointer<KeyGenerateInfo>& params, + const DataObjectPtr& data_object) -> GpgError { + if (params == nullptr || params->GetAlgo() == KeyGenerateInfo::kNoneAlgo || + params->IsSubKey()) { + return GPG_ERR_CANCELED; + } + + const auto userid = params->GetUserid(); + const auto algo = params->GetAlgo().Id(); + + unsigned long expires = + QDateTime::currentDateTime().secsTo(params->GetExpireTime()); + + GpgError err; + unsigned int flags = 0; + + if (!params->IsSubKey()) flags |= GPGME_CREATE_CERT; + if (params->IsAllowEncr()) flags |= GPGME_CREATE_ENCR; + if (params->IsAllowSign()) flags |= GPGME_CREATE_SIGN; + if (params->IsAllowAuth()) flags |= GPGME_CREATE_AUTH; + if (params->IsNonExpired()) flags |= GPGME_CREATE_NOEXPIRE; + if (params->IsNoPassPhrase()) flags |= GPGME_CREATE_NOPASSWD; + + LOG_D() << "key generation args: " << userid << algo << expires << flags; + LOG_D() << "key generation flags" << params->IsAllowEncr() + << params->IsAllowSign() << params->IsAllowAuth() + << !params->IsSubKey(); + + err = gpgme_op_createkey(ctx.DefaultContext(), userid.toUtf8(), algo.toUtf8(), + 0, expires, nullptr, flags); + + if (CheckGpgError(err) == GPG_ERR_NO_ERROR) { + data_object->Swap( + {GpgGenerateKeyResult{gpgme_op_genkey_result(ctx.DefaultContext())}}); + } else { + data_object->Swap({GpgGenerateKeyResult{}}); + } + + return CheckGpgError(err); +} + /** * Generate a new key pair * @param params key generation args * @return error information */ -void GpgKeyOpera::GenerateKey(const std::shared_ptr<GenKeyInfo>& params, +void GpgKeyOpera::GenerateKey(const QSharedPointer<KeyGenerateInfo>& params, const GpgOperationCallback& callback) { RunGpgOperaAsync( - [&ctx = ctx_, params](const DataObjectPtr& data_object) -> GpgError { - auto userid = params->GetUserid(); - auto algo = params->GetAlgo() + params->GetKeySizeStr(); - - LOG_D() << "params: " << params->GetAlgo() << params->GetKeySizeStr(); - - unsigned long expires = - QDateTime::currentDateTime().secsTo(params->GetExpireTime()); - - GpgError err; - unsigned int flags = 0; - - if (!params->IsSubKey()) flags |= GPGME_CREATE_CERT; - if (params->IsAllowEncryption()) flags |= GPGME_CREATE_ENCR; - if (params->IsAllowSigning()) flags |= GPGME_CREATE_SIGN; - if (params->IsAllowAuthentication()) flags |= GPGME_CREATE_AUTH; - if (params->IsNonExpired()) flags |= GPGME_CREATE_NOEXPIRE; - if (params->IsNoPassPhrase()) flags |= GPGME_CREATE_NOPASSWD; - - LOG_D() << "key generation args: " << userid << algo << expires - << flags; - - err = gpgme_op_createkey(ctx.DefaultContext(), userid.toUtf8(), - algo.toUtf8(), 0, expires, nullptr, flags); - assert(gpg_err_code(err) == GPG_ERR_NO_ERROR); - - if (CheckGpgError(err) == GPG_ERR_NO_ERROR) { - data_object->Swap({GpgGenerateKeyResult{ - gpgme_op_genkey_result(ctx.DefaultContext())}}); - } else { - data_object->Swap({GpgGenerateKeyResult{}}); - } - - return CheckGpgError(err); + [=](const DataObjectPtr& data_object) -> GpgError { + return GenerateKeyImpl(ctx_, params, data_object); }, callback, "gpgme_op_createkey", "2.1.0"); } -auto GpgKeyOpera::GenerateKeySync(const std::shared_ptr<GenKeyInfo>& params) +auto GpgKeyOpera::GenerateKeySync(const QSharedPointer<KeyGenerateInfo>& params) -> std::tuple<GpgError, DataObjectPtr> { return RunGpgOperaSync( - [=, &ctx = ctx_](const DataObjectPtr& data_object) -> GpgError { - auto userid = params->GetUserid(); - auto algo = params->GetAlgo() + params->GetKeySizeStr(); - - LOG_D() << "params: " << params->GetAlgo() << params->GetKeySizeStr(); - - unsigned long expires = - QDateTime::currentDateTime().secsTo(params->GetExpireTime()); - - GpgError err; - unsigned int flags = 0; - - if (!params->IsSubKey()) flags |= GPGME_CREATE_CERT; - if (params->IsAllowEncryption()) flags |= GPGME_CREATE_ENCR; - if (params->IsAllowSigning()) flags |= GPGME_CREATE_SIGN; - if (params->IsAllowAuthentication()) flags |= GPGME_CREATE_AUTH; - if (params->IsNonExpired()) flags |= GPGME_CREATE_NOEXPIRE; - if (params->IsNoPassPhrase()) flags |= GPGME_CREATE_NOPASSWD; - - LOG_D() << "key generation args: " << userid << algo << expires - << flags; + [=](const DataObjectPtr& data_object) -> GpgError { + return GenerateKeyImpl(ctx_, params, data_object); + }, + "gpgme_op_createkey", "2.1.0"); +} - err = gpgme_op_createkey(ctx.DefaultContext(), userid.toUtf8(), - algo.toUtf8(), 0, expires, nullptr, flags); - assert(gpg_err_code(err) == GPG_ERR_NO_ERROR); +auto GenerateSubKeyImpl(GpgContext& ctx, const GpgKey& key, + const QSharedPointer<KeyGenerateInfo>& params, + const DataObjectPtr& data_object) -> GpgError { + if (params == nullptr || params->GetAlgo() == KeyGenerateInfo::kNoneAlgo || + !params->IsSubKey()) { + return GPG_ERR_CANCELED; + } - if (CheckGpgError(err) == GPG_ERR_NO_ERROR) { - data_object->Swap({GpgGenerateKeyResult{ - gpgme_op_genkey_result(ctx.DefaultContext())}}); - } else { - data_object->Swap({GpgGenerateKeyResult{}}); - } + auto algo = params->GetAlgo().Id(); + unsigned long expires = + QDateTime::currentDateTime().secsTo(params->GetExpireTime()); + unsigned int flags = 0; + + if (!params->IsSubKey()) flags |= GPGME_CREATE_CERT; + if (params->IsAllowEncr()) flags |= GPGME_CREATE_ENCR; + if (params->IsAllowSign()) flags |= GPGME_CREATE_SIGN; + if (params->IsAllowAuth()) flags |= GPGME_CREATE_AUTH; + if (params->IsNonExpired()) flags |= GPGME_CREATE_NOEXPIRE; + if (params->IsNoPassPhrase()) flags |= GPGME_CREATE_NOPASSWD; + + LOG_D() << "subkey generation args: " << key.GetId() << algo << expires + << flags; + + auto err = + gpgme_op_createsubkey(ctx.DefaultContext(), static_cast<gpgme_key_t>(key), + algo.toLatin1(), 0, expires, flags); + if (CheckGpgError(err) != GPG_ERR_NO_ERROR) { + data_object->Swap({GpgGenerateKeyResult{}}); + return err; + } - return CheckGpgError(err); - }, - "gpgme_op_createkey", "2.1.0"); + data_object->Swap( + {GpgGenerateKeyResult{gpgme_op_genkey_result(ctx.DefaultContext())}}); + return CheckGpgError(err); } void GpgKeyOpera::GenerateSubkey(const GpgKey& key, - const std::shared_ptr<GenKeyInfo>& params, + const QSharedPointer<KeyGenerateInfo>& params, const GpgOperationCallback& callback) { RunGpgOperaAsync( - [key, &ctx = ctx_, params](const DataObjectPtr& data_object) -> GpgError { - if (!params->IsSubKey()) return GPG_ERR_CANCELED; - - LOG_D() << "generate subkey algo: " << params->GetAlgo() - << "key size: " << params->GetKeySizeStr(); - - auto algo = params->GetAlgo() + params->GetKeySizeStr(); - unsigned long expires = - QDateTime::currentDateTime().secsTo(params->GetExpireTime()); - unsigned int flags = 0; - - if (!params->IsSubKey()) flags |= GPGME_CREATE_CERT; - if (params->IsAllowEncryption()) flags |= GPGME_CREATE_ENCR; - if (params->IsAllowSigning()) flags |= GPGME_CREATE_SIGN; - if (params->IsAllowAuthentication()) flags |= GPGME_CREATE_AUTH; - if (params->IsNonExpired()) flags |= GPGME_CREATE_NOEXPIRE; - if (params->IsNoPassPhrase()) flags |= GPGME_CREATE_NOPASSWD; - - LOG_D() << "subkey generation args: " << key.GetId() << algo << expires - << flags; - - auto err = gpgme_op_createsubkey(ctx.DefaultContext(), - static_cast<gpgme_key_t>(key), - algo.toLatin1(), 0, expires, flags); - if (CheckGpgError(err) != GPG_ERR_NO_ERROR) { - data_object->Swap({GpgGenerateKeyResult{}}); - return err; - } - - data_object->Swap({GpgGenerateKeyResult{ - gpgme_op_genkey_result(ctx.DefaultContext())}}); - return CheckGpgError(err); + [=](const DataObjectPtr& data_object) -> GpgError { + return GenerateSubKeyImpl(ctx_, key, params, data_object); }, callback, "gpgme_op_createsubkey", "2.1.13"); } -auto GpgKeyOpera::GenerateSubkeySync(const GpgKey& key, - const std::shared_ptr<GenKeyInfo>& params) +auto GpgKeyOpera::GenerateSubkeySync( + const GpgKey& key, const QSharedPointer<KeyGenerateInfo>& params) -> std::tuple<GpgError, DataObjectPtr> { return RunGpgOperaSync( - [key, &ctx = ctx_, params](const DataObjectPtr& data_object) -> GpgError { - if (!params->IsSubKey()) return GPG_ERR_CANCELED; - - LOG_D() << "generate subkey algo: " << params->GetAlgo() - << " key size: " << params->GetKeySizeStr(); - - auto algo = params->GetAlgo() + params->GetKeySizeStr(); - unsigned long expires = - QDateTime::currentDateTime().secsTo(params->GetExpireTime()); - unsigned int flags = 0; - - if (!params->IsSubKey()) flags |= GPGME_CREATE_CERT; - if (params->IsAllowEncryption()) flags |= GPGME_CREATE_ENCR; - if (params->IsAllowSigning()) flags |= GPGME_CREATE_SIGN; - if (params->IsAllowAuthentication()) flags |= GPGME_CREATE_AUTH; - if (params->IsNonExpired()) flags |= GPGME_CREATE_NOEXPIRE; - if (params->IsNoPassPhrase()) flags |= GPGME_CREATE_NOPASSWD; - - LOG_D() << " args: " << key.GetId() << algo << expires << flags; - - auto err = gpgme_op_createsubkey(ctx.DefaultContext(), - static_cast<gpgme_key_t>(key), - algo.toLatin1(), 0, expires, flags); - - if (CheckGpgError(err) != GPG_ERR_NO_ERROR) { - data_object->Swap({GpgGenerateKeyResult{}}); - return err; - } - - data_object->Swap({GpgGenerateKeyResult{ - gpgme_op_genkey_result(ctx.DefaultContext())}}); - return CheckGpgError(err); + [=](const DataObjectPtr& data_object) -> GpgError { + return GenerateSubKeyImpl(ctx_, key, params, data_object); }, "gpgme_op_createsubkey", "2.1.13"); } +auto GenerateKeyWithSubkeyImpl(GpgContext& ctx, GpgKeyGetter& key_getter, + const QSharedPointer<KeyGenerateInfo>& p_params, + const QSharedPointer<KeyGenerateInfo>& s_params, + const DataObjectPtr& data_object) -> GpgError { + auto err = GenerateKeyImpl(ctx, p_params, data_object); + + if (err != GPG_ERR_NO_ERROR) return err; + if (!data_object->Check<GpgGenerateKeyResult>()) return GPG_ERR_CANCELED; + + auto result = ExtractParams<GpgGenerateKeyResult>(data_object, 0); + auto key = key_getter.GetKey(result.GetFingerprint()); + if (!key.IsGood()) { + LOG_W() << "cannot get key which has been generated, fpr: " + << result.GetFingerprint(); + return GPG_ERR_CANCELED; + } + + if (s_params == nullptr) return err; + + data_object->Swap({}); + err = GenerateSubKeyImpl(ctx, key, s_params, data_object); + auto s_result = ExtractParams<GpgGenerateKeyResult>(data_object, 0); + + data_object->Swap({result, s_result}); + return err; +} + void GpgKeyOpera::GenerateKeyWithSubkey( - const std::shared_ptr<GenKeyInfo>& params, - const std::shared_ptr<GenKeyInfo>& subkey_params, + const QSharedPointer<KeyGenerateInfo>& p_params, + const QSharedPointer<KeyGenerateInfo>& s_params, const GpgOperationCallback& callback) { RunGpgOperaAsync( - [&ctx = ctx_, params, subkey_params, - channel = GetChannel()](const DataObjectPtr& data_object) -> GpgError { - auto userid = params->GetUserid().toUtf8(); - auto algo = (params->GetAlgo() + params->GetKeySizeStr()).toUtf8(); - unsigned long expires = - QDateTime::currentDateTime().secsTo(params->GetExpireTime()); - - GpgError err; - unsigned int flags = 0; - - if (!params->IsSubKey()) flags |= GPGME_CREATE_CERT; - if (params->IsAllowEncryption()) flags |= GPGME_CREATE_ENCR; - if (params->IsAllowSigning()) flags |= GPGME_CREATE_SIGN; - if (params->IsAllowAuthentication()) flags |= GPGME_CREATE_AUTH; - if (params->IsNonExpired()) flags |= GPGME_CREATE_NOEXPIRE; - if (params->IsNoPassPhrase()) flags |= GPGME_CREATE_NOPASSWD; - - LOG_D() << "key generation args: " << userid << algo << expires - << flags; - - err = gpgme_op_createkey(ctx.DefaultContext(), userid, algo, 0, expires, - nullptr, flags); - assert(gpg_err_code(err) == GPG_ERR_NO_ERROR); - - if (CheckGpgError(err) != GPG_ERR_NO_ERROR) { - data_object->Swap({GpgGenerateKeyResult{}}); - return err; - } - - auto genkey_result = - GpgGenerateKeyResult{gpgme_op_genkey_result(ctx.DefaultContext())}; - - if (subkey_params == nullptr || !subkey_params->IsSubKey()) { - data_object->Swap({genkey_result}); - return err; - } - - auto key = GpgKeyGetter::GetInstance(channel).GetKey( - genkey_result.GetFingerprint()); - if (!key.IsGood()) { - LOG_W() << "cannot get key which has been generate, fpr: " - << genkey_result.GetFingerprint(); - return err; - } - - algo = (subkey_params->GetAlgo() + subkey_params->GetKeySizeStr()) - .toUtf8(); - expires = - QDateTime::currentDateTime().secsTo(subkey_params->GetExpireTime()); - - flags = 0; - if (subkey_params->IsAllowEncryption()) flags |= GPGME_CREATE_ENCR; - if (subkey_params->IsAllowSigning()) flags |= GPGME_CREATE_SIGN; - if (subkey_params->IsAllowAuthentication()) flags |= GPGME_CREATE_AUTH; - if (subkey_params->IsNonExpired()) flags |= GPGME_CREATE_NOEXPIRE; - if (subkey_params->IsNoPassPhrase()) flags |= GPGME_CREATE_NOPASSWD; - - LOG_D() << "subkey generation args: " << key.GetId() << algo << expires - << flags; - - err = gpgme_op_createsubkey(ctx.DefaultContext(), - static_cast<gpgme_key_t>(key), algo, 0, - expires, flags); - - if (CheckGpgError(err) == GPG_ERR_NO_ERROR) { - data_object->Swap( - {genkey_result, GpgGenerateKeyResult{gpgme_op_genkey_result( - ctx.DefaultContext())}}); - } else { - data_object->Swap({genkey_result, GpgGenerateKeyResult{}}); - } - - return CheckGpgError(err); + [=](const DataObjectPtr& data_object) -> GpgError { + return GenerateKeyWithSubkeyImpl(ctx_, key_getter_, p_params, s_params, + data_object); }, callback, "gpgme_op_createkey&gpgme_op_createsubkey", "2.1.0"); } auto GpgKeyOpera::GenerateKeyWithSubkeySync( - const std::shared_ptr<GenKeyInfo>& params, - const std::shared_ptr<GenKeyInfo>& subkey_params) + const QSharedPointer<KeyGenerateInfo>& p_params, + const QSharedPointer<KeyGenerateInfo>& s_params) -> std::tuple<GpgError, DataObjectPtr> { return RunGpgOperaSync( - [&ctx = ctx_, params, subkey_params, - channel = GetChannel()](const DataObjectPtr& data_object) -> GpgError { - auto userid = params->GetUserid().toUtf8(); - auto algo = (params->GetAlgo() + params->GetKeySizeStr()).toUtf8(); - unsigned long expires = - QDateTime::currentDateTime().secsTo(params->GetExpireTime()); - - GpgError err; - unsigned int flags = 0; - - if (!params->IsSubKey()) flags |= GPGME_CREATE_CERT; - if (params->IsAllowEncryption()) flags |= GPGME_CREATE_ENCR; - if (params->IsAllowSigning()) flags |= GPGME_CREATE_SIGN; - if (params->IsAllowAuthentication()) flags |= GPGME_CREATE_AUTH; - if (params->IsNonExpired()) flags |= GPGME_CREATE_NOEXPIRE; - if (params->IsNoPassPhrase()) flags |= GPGME_CREATE_NOPASSWD; - - LOG_D() << "key generation args: " << userid << algo << expires - << flags; - - err = gpgme_op_createkey(ctx.DefaultContext(), userid, algo, 0, expires, - nullptr, flags); - assert(gpg_err_code(err) == GPG_ERR_NO_ERROR); - - if (CheckGpgError(err) != GPG_ERR_NO_ERROR) { - data_object->Swap({GpgGenerateKeyResult{}}); - return err; - } - - auto genkey_result = - GpgGenerateKeyResult{gpgme_op_genkey_result(ctx.DefaultContext())}; - - if (subkey_params == nullptr || !subkey_params->IsSubKey()) { - data_object->Swap({genkey_result}); - return err; - } - - auto key = GpgKeyGetter::GetInstance(channel).GetKey( - genkey_result.GetFingerprint()); - if (!key.IsGood()) { - LOG_W() << "cannot get key which has been generate, fpr: " - << genkey_result.GetFingerprint(); - return err; - } - - LOG_D() << "try to generate subkey of key: " << key.GetId() - << ", algo :" << subkey_params->GetAlgo() - << ", key size: " << subkey_params->GetKeySizeStr(); - - algo = (subkey_params->GetAlgo() + subkey_params->GetKeySizeStr()) - .toUtf8(); - expires = - QDateTime::currentDateTime().secsTo(subkey_params->GetExpireTime()); - - flags = 0; - if (subkey_params->IsAllowEncryption()) flags |= GPGME_CREATE_ENCR; - if (subkey_params->IsAllowSigning()) flags |= GPGME_CREATE_SIGN; - if (subkey_params->IsAllowAuthentication()) flags |= GPGME_CREATE_AUTH; - if (subkey_params->IsNonExpired()) flags |= GPGME_CREATE_NOEXPIRE; - if (subkey_params->IsNoPassPhrase()) flags |= GPGME_CREATE_NOPASSWD; - - LOG_D() << "subkey generation args: " << key.GetId() << algo << expires - << flags; - - err = gpgme_op_createsubkey(ctx.DefaultContext(), - static_cast<gpgme_key_t>(key), algo, 0, - expires, flags); - - if (CheckGpgError(err) == GPG_ERR_NO_ERROR) { - data_object->Swap( - {genkey_result, GpgGenerateKeyResult{gpgme_op_genkey_result( - ctx.DefaultContext())}}); - } else { - data_object->Swap({genkey_result, GpgGenerateKeyResult{}}); - } - - return CheckGpgError(err); + [=](const DataObjectPtr& data_object) -> GpgError { + return GenerateKeyWithSubkeyImpl(ctx_, key_getter_, p_params, s_params, + data_object); }, "gpgme_op_createkey&gpgme_op_createsubkey", "2.1.0"); } @@ -532,8 +360,8 @@ auto GpgKeyOpera::ModifyTOFUPolicy( } void GpgKeyOpera::DeleteKey(const KeyId& key_id) { - auto keys = std::make_unique<KeyIdArgsList>(); - keys->push_back(key_id); - DeleteKeys(std::move(keys)); + auto keys = KeyIdArgsList{}; + keys.push_back(key_id); + DeleteKeys(keys); } } // namespace GpgFrontend diff --git a/src/core/function/gpg/GpgKeyOpera.h b/src/core/function/gpg/GpgKeyOpera.h index 7b8a01a1..f6b7143e 100644 --- a/src/core/function/gpg/GpgKeyOpera.h +++ b/src/core/function/gpg/GpgKeyOpera.h @@ -31,6 +31,7 @@ #include <functional> #include "core/function/gpg/GpgContext.h" +#include "core/function/gpg/GpgKeyGetter.h" #include "core/typedef/GpgTypedef.h" namespace GpgFrontend { @@ -38,7 +39,7 @@ namespace GpgFrontend { * @brief * */ -class GenKeyInfo; +class KeyGenerateInfo; /** * @brief @@ -60,7 +61,7 @@ class GPGFRONTEND_CORE_EXPORT GpgKeyOpera * * @param key_ids */ - void DeleteKeys(KeyIdArgsListPtr key_ids); + void DeleteKeys(KeyIdArgsList key_ids); /** * @brief @@ -114,7 +115,7 @@ class GPGFRONTEND_CORE_EXPORT GpgKeyOpera * @param result * @return GpgFrontend::GpgError */ - void GenerateKey(const std::shared_ptr<GenKeyInfo>&, + void GenerateKey(const QSharedPointer<KeyGenerateInfo>&, const GpgOperationCallback&); /** @@ -122,7 +123,7 @@ class GPGFRONTEND_CORE_EXPORT GpgKeyOpera * * @param params */ - auto GenerateKeySync(const std::shared_ptr<GenKeyInfo>& params) + auto GenerateKeySync(const QSharedPointer<KeyGenerateInfo>& params) -> std::tuple<GpgError, DataObjectPtr>; /** @@ -133,7 +134,7 @@ class GPGFRONTEND_CORE_EXPORT GpgKeyOpera * @return GpgFrontend::GpgError */ void GenerateSubkey(const GpgKey& key, - const std::shared_ptr<GenKeyInfo>& params, + const QSharedPointer<KeyGenerateInfo>& params, const GpgOperationCallback&); /** @@ -143,7 +144,7 @@ class GPGFRONTEND_CORE_EXPORT GpgKeyOpera * @param params */ auto GenerateSubkeySync(const GpgKey& key, - const std::shared_ptr<GenKeyInfo>& params) + const QSharedPointer<KeyGenerateInfo>& params) -> std::tuple<GpgError, DataObjectPtr>; /** @@ -153,8 +154,8 @@ class GPGFRONTEND_CORE_EXPORT GpgKeyOpera * @param subkey_params * @param callback */ - void GenerateKeyWithSubkey(const std::shared_ptr<GenKeyInfo>& params, - const std::shared_ptr<GenKeyInfo>& subkey_params, + void GenerateKeyWithSubkey(const QSharedPointer<KeyGenerateInfo>& p_params, + const QSharedPointer<KeyGenerateInfo>& s_params, const GpgOperationCallback& callback); /** @@ -165,12 +166,15 @@ class GPGFRONTEND_CORE_EXPORT GpgKeyOpera * @param callback */ auto GenerateKeyWithSubkeySync( - const std::shared_ptr<GenKeyInfo>& params, - const std::shared_ptr<GenKeyInfo>& subkey_params) + const QSharedPointer<KeyGenerateInfo>& p_params, + const QSharedPointer<KeyGenerateInfo>& s_params) -> std::tuple<GpgError, DataObjectPtr>; private: GpgContext& ctx_ = GpgContext::GetInstance(SingletonFunctionObject::GetChannel()); ///< + + GpgKeyGetter& key_getter_ = + GpgKeyGetter::GetInstance(SingletonFunctionObject::GetChannel()); ///< }; } // namespace GpgFrontend diff --git a/src/core/function/gpg/GpgUIDOperator.cpp b/src/core/function/gpg/GpgUIDOperator.cpp index 3fc506f4..e87a710d 100644 --- a/src/core/function/gpg/GpgUIDOperator.cpp +++ b/src/core/function/gpg/GpgUIDOperator.cpp @@ -155,15 +155,8 @@ auto GpgUIDOperator::RevokeUID(const GpgKey& key, int uid_index, } // dealing with reason text -#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 4) - auto reason_text_lines = - GpgFrontend::SecureCreateSharedObject<QList<QString>>( - reason_text.split('\n', Qt::SkipEmptyParts).toVector()); -#else - auto reason_text_lines = - GpgFrontend::SecureCreateSharedObject<QVector<QString>>( - reason_text.split('\n', Qt::SkipEmptyParts).toVector()); -#endif + auto reason_text_lines = GpgFrontend::SecureCreateSharedObject<QStringList>( + reason_text.split('\n', Qt::SkipEmptyParts).toVector()); AutomatonNextStateHandler next_state_handler = [](AutomatonState state, QString status, diff --git a/src/core/function/result_analyse/GpgResultAnalyse.h b/src/core/function/result_analyse/GpgResultAnalyse.h index ce47764c..fa84ddb4 100644 --- a/src/core/function/result_analyse/GpgResultAnalyse.h +++ b/src/core/function/result_analyse/GpgResultAnalyse.h @@ -27,10 +27,6 @@ */ #pragma once -#include <sstream> - -#include "core/typedef/GpgTypedef.h" - namespace GpgFrontend { class GPGFRONTEND_CORE_EXPORT GpgResultAnalyse : public QObject { diff --git a/src/core/function/result_analyse/GpgVerifyResultAnalyse.cpp b/src/core/function/result_analyse/GpgVerifyResultAnalyse.cpp index 9512189d..e2fc21f0 100644 --- a/src/core/function/result_analyse/GpgVerifyResultAnalyse.cpp +++ b/src/core/function/result_analyse/GpgVerifyResultAnalyse.cpp @@ -256,6 +256,6 @@ auto GpgFrontend::GpgVerifyResultAnalyse::TakeChargeOfResult() } auto GpgFrontend::GpgVerifyResultAnalyse::GetUnknownSignatures() const - -> QList<QString> { + -> QStringList { return unknown_signer_fpr_list_; } diff --git a/src/core/function/result_analyse/GpgVerifyResultAnalyse.h b/src/core/function/result_analyse/GpgVerifyResultAnalyse.h index b3e318b8..719bb107 100644 --- a/src/core/function/result_analyse/GpgVerifyResultAnalyse.h +++ b/src/core/function/result_analyse/GpgVerifyResultAnalyse.h @@ -65,9 +65,9 @@ class GPGFRONTEND_CORE_EXPORT GpgVerifyResultAnalyse : public GpgResultAnalyse { /** * @brief Get the Unknown Signatures object * - * @return QList<QString> + * @return QStringList */ - [[nodiscard]] auto GetUnknownSignatures() const -> QList<QString>; + [[nodiscard]] auto GetUnknownSignatures() const -> QStringList; protected: /** @@ -99,7 +99,7 @@ class GPGFRONTEND_CORE_EXPORT GpgVerifyResultAnalyse : public GpgResultAnalyse { GpgError error_; ///< GpgVerifyResult result_; ///< - QList<QString> unknown_signer_fpr_list_; + QStringList unknown_signer_fpr_list_; }; } // namespace GpgFrontend |