aboutsummaryrefslogtreecommitdiffstats
path: root/src/core/function
diff options
context:
space:
mode:
Diffstat (limited to 'src/core/function')
-rw-r--r--src/core/function/ArchiveFileOperator.cpp11
-rw-r--r--src/core/function/gpg/GpgBasicOperator.cpp232
-rw-r--r--src/core/function/gpg/GpgBasicOperator.h97
-rw-r--r--src/core/function/gpg/GpgContext.cpp11
-rw-r--r--src/core/function/gpg/GpgFileOpera.cpp212
-rw-r--r--src/core/function/gpg/GpgFileOpera.h107
-rw-r--r--src/core/function/gpg/GpgKeyOpera.cpp209
-rw-r--r--src/core/function/gpg/GpgKeyOpera.h30
8 files changed, 819 insertions, 90 deletions
diff --git a/src/core/function/ArchiveFileOperator.cpp b/src/core/function/ArchiveFileOperator.cpp
index ef04d69f..54c78628 100644
--- a/src/core/function/ArchiveFileOperator.cpp
+++ b/src/core/function/ArchiveFileOperator.cpp
@@ -159,21 +159,10 @@ void ArchiveFileOperator::NewArchive2DataExchanger(
auto fd = open(archive_entry_sourcepath(entry), O_RDONLY);
auto len = read(fd, buff.data(), buff.size());
assert(len <= buff.size() && len > 0);
- if (len == -1) {
- GF_CORE_LOG_ERROR("read() failed, ret: {}, abort ...", len);
- archive_entry_free(entry);
- close(fd);
- break;
- }
-
while (len > 0) {
archive_write_data(archive, buff.data(), len);
len = read(fd, buff.data(), buff.size());
assert(len <= buff.size() && len > 0);
- if (len == -1) {
- GF_CORE_LOG_ERROR("read() failed, ret: {}, abort ...", len);
- break;
- }
}
close(fd);
}
diff --git a/src/core/function/gpg/GpgBasicOperator.cpp b/src/core/function/gpg/GpgBasicOperator.cpp
index e5916c77..8b62aad0 100644
--- a/src/core/function/gpg/GpgBasicOperator.cpp
+++ b/src/core/function/gpg/GpgBasicOperator.cpp
@@ -43,9 +43,11 @@ namespace GpgFrontend {
GpgBasicOperator::GpgBasicOperator(int channel)
: SingletonFunctionObject<GpgBasicOperator>(channel) {}
-void GpgBasicOperator::Encrypt(KeyArgsList keys, GFBuffer in_buffer, bool ascii,
+void GpgBasicOperator::Encrypt(const KeyArgsList& keys,
+ const GFBuffer& in_buffer, bool ascii,
const GpgOperationCallback& cb) {
- RunGpgOperaAsync([=](const DataObjectPtr& data_object) -> GpgError {
+ RunGpgOperaAsync(
+ [=](const DataObjectPtr& data_object) -> GpgError {
if (keys.empty()) return GPG_ERR_CANCELED;
std::vector<gpgme_key_t> recipients(keys.begin(), keys.end());
@@ -68,7 +70,71 @@ void GpgBasicOperator::Encrypt(KeyArgsList keys, GFBuffer in_buffer, bool ascii,
cb, "gpgme_op_encrypt", "2.1.0");
}
-void GpgBasicOperator::Decrypt(GFBuffer in_buffer,
+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;
+ },
+ "gpgme_op_encrypt", "2.1.0");
+}
+
+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;
+ },
+ cb, "gpgme_op_encrypt_symmetric", "2.1.0");
+}
+
+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;
+ },
+ "gpgme_op_encrypt_symmetric", "2.1.0");
+}
+
+void GpgBasicOperator::Decrypt(const GFBuffer& in_buffer,
const GpgOperationCallback& cb) {
RunGpgOperaAsync(
[=](const DataObjectPtr& data_object) -> GpgError {
@@ -86,7 +152,26 @@ void GpgBasicOperator::Decrypt(GFBuffer in_buffer,
cb, "gpgme_op_decrypt", "2.1.0");
}
-void GpgBasicOperator::Verify(GFBuffer in_buffer, GFBuffer sig_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;
+ },
+ "gpgme_op_decrypt", "2.1.0");
+}
+
+void GpgBasicOperator::Verify(const GFBuffer& in_buffer,
+ const GFBuffer& sig_buffer,
const GpgOperationCallback& cb) {
RunGpgOperaAsync(
[=](const DataObjectPtr& data_object) -> GpgError {
@@ -113,9 +198,37 @@ void GpgBasicOperator::Verify(GFBuffer in_buffer, GFBuffer sig_buffer,
cb, "gpgme_op_verify", "2.1.0");
}
-void GpgBasicOperator::Sign(KeyArgsList signers, GFBuffer in_buffer,
- GpgSignMode mode, bool ascii,
- const GpgOperationCallback& cb) {
+auto GpgBasicOperator::VerifySync(const GFBuffer& in_buffer,
+ const GFBuffer& sig_buffer)
+ -> std::tuple<GpgError, DataObjectPtr> {
+ return RunGpgOperaSync(
+ [=](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;
+ },
+ "gpgme_op_verify", "2.1.0");
+}
+
+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;
@@ -138,7 +251,33 @@ void GpgBasicOperator::Sign(KeyArgsList signers, GFBuffer in_buffer,
cb, "gpgme_op_sign", "2.1.0");
}
-void GpgBasicOperator::DecryptVerify(GFBuffer in_buffer,
+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;
+
+ 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;
+ },
+ "gpgme_op_sign", "2.1.0");
+}
+
+void GpgBasicOperator::DecryptVerify(const GFBuffer& in_buffer,
const GpgOperationCallback& cb) {
RunGpgOperaAsync(
[=](const DataObjectPtr& data_object) -> GpgError {
@@ -160,8 +299,31 @@ void GpgBasicOperator::DecryptVerify(GFBuffer in_buffer,
cb, "gpgme_op_decrypt_verify", "2.1.0");
}
-void GpgBasicOperator::EncryptSign(KeyArgsList keys, KeyArgsList signers,
- GFBuffer in_buffer, bool ascii,
+auto GpgBasicOperator::DecryptVerifySync(const GFBuffer& in_buffer)
+ -> std::tuple<GpgError, DataObjectPtr> {
+ return RunGpgOperaSync(
+ [=](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;
+ },
+ "gpgme_op_decrypt_verify", "2.1.0");
+}
+
+void GpgBasicOperator::EncryptSign(const KeyArgsList& keys,
+ const KeyArgsList& signers,
+ const GFBuffer& in_buffer, bool ascii,
const GpgOperationCallback& cb) {
RunGpgOperaAsync(
[=](const DataObjectPtr& data_object) -> GpgError {
@@ -191,6 +353,38 @@ void GpgBasicOperator::EncryptSign(KeyArgsList keys, KeyArgsList signers,
cb, "gpgme_op_encrypt_sign", "2.1.0");
}
+auto GpgBasicOperator::EncryptSignSync(const KeyArgsList& keys,
+ const KeyArgsList& signers,
+ const GFBuffer& in_buffer, bool ascii)
+ -> 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;
+ },
+ "gpgme_op_encrypt_sign", "2.1.0");
+}
+
void GpgBasicOperator::SetSigners(const KeyArgsList& signers, bool ascii) {
auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
@@ -219,22 +413,4 @@ auto GpgBasicOperator::GetSigners(bool ascii) -> std::unique_ptr<KeyArgsList> {
}
return signers;
}
-
-void GpgBasicOperator::EncryptSymmetric(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;
- },
- cb, "gpgme_op_encrypt_symmetric", "2.1.0");
-}
} // namespace GpgFrontend
diff --git a/src/core/function/gpg/GpgBasicOperator.h b/src/core/function/gpg/GpgBasicOperator.h
index 4b1a2688..37defb45 100644
--- a/src/core/function/gpg/GpgBasicOperator.h
+++ b/src/core/function/gpg/GpgBasicOperator.h
@@ -55,11 +55,16 @@ class GPGFRONTEND_CORE_EXPORT GpgBasicOperator
/**
* @brief
*
- * All incoming data pointers out_buffer will be replaced with new valid
- * values
+ */
+ void Encrypt(const KeyArgsList&, const GFBuffer&, bool,
+ const GpgOperationCallback&);
+
+ /**
+ * @brief
*
*/
- void Encrypt(KeyArgsList, GFBuffer, bool, const GpgOperationCallback&);
+ auto EncryptSync(const KeyArgsList&, const GFBuffer&, bool)
+ -> std::tuple<GpgError, DataObjectPtr>;
/**
* @brief Call the interface provided by GPGME to symmetrical encryption
@@ -69,10 +74,21 @@ class GPGFRONTEND_CORE_EXPORT GpgBasicOperator
* @param result Encrypted results
* @return GpgError
*/
- void EncryptSymmetric(GFBuffer in_buffer, bool ascii,
+ void EncryptSymmetric(const GFBuffer& in_buffer, bool ascii,
const GpgOperationCallback& cb);
/**
+ * @brief
+ *
+ * @param in_buffer
+ * @param ascii
+ * @param cb
+ * @return std::tuple<GpgError, DataObjectPtr>
+ */
+ auto EncryptSymmetricSync(const GFBuffer& in_buffer, bool ascii)
+ -> std::tuple<GpgError, DataObjectPtr>;
+
+ /**
*
* @brief Call the interface provided by gpgme to perform encryption and
* signature operations at the same time.
@@ -80,13 +96,25 @@ class GPGFRONTEND_CORE_EXPORT GpgBasicOperator
* @param keys List of public keys
* @param signers Private key for signatures
* @param in_buffer Data for operation
- * @param out_buffer Encrypted data
- * @param encr_result Encrypted results
- * @param sign_result Signature result
+ * @param ascii ascii mode
* @return
*/
- void EncryptSign(KeyArgsList keys, KeyArgsList signers, GFBuffer in_buffer,
- bool ascii, const GpgOperationCallback& cb);
+ void EncryptSign(const KeyArgsList& keys, const KeyArgsList& signers,
+ const GFBuffer& in_buffer, bool ascii,
+ const GpgOperationCallback& cb);
+
+ /**
+ * @brief
+ *
+ * @param keys
+ * @param signers
+ * @param in_buffer
+ * @param ascii
+ * @param cb
+ */
+ auto EncryptSignSync(const KeyArgsList& keys, const KeyArgsList& signers,
+ const GFBuffer& in_buffer, bool ascii)
+ -> std::tuple<GpgError, DataObjectPtr>;
/**
* @brief Call the interface provided by gpgme for decryption operation
@@ -96,7 +124,15 @@ class GPGFRONTEND_CORE_EXPORT GpgBasicOperator
* @param result the result of the operation
* @return error code
*/
- void Decrypt(GFBuffer in_buffer, const GpgOperationCallback& cb);
+ void Decrypt(const GFBuffer& in_buffer, const GpgOperationCallback& cb);
+
+ /**
+ * @brief
+ *
+ * @param in_buffer
+ */
+ auto DecryptSync(const GFBuffer& in_buffer)
+ -> std::tuple<GpgError, DataObjectPtr>;
/**
* @brief Call the interface provided by gpgme to perform decryption and
@@ -108,7 +144,15 @@ class GPGFRONTEND_CORE_EXPORT GpgBasicOperator
* @param verify_result the result of the verifying operation
* @return error code
*/
- void DecryptVerify(GFBuffer in_buffer, const GpgOperationCallback& cb);
+ void DecryptVerify(const GFBuffer& in_buffer, const GpgOperationCallback& cb);
+
+ /**
+ * @brief
+ *
+ * @param in_buffer
+ */
+ auto DecryptVerifySync(const GFBuffer& in_buffer)
+ -> std::tuple<GpgError, DataObjectPtr>;
/**
* @brief Call the interface provided by gpgme for verification operation
@@ -118,10 +162,21 @@ class GPGFRONTEND_CORE_EXPORT GpgBasicOperator
* @param result the result of the operation
* @return error code
*/
- void Verify(GFBuffer in_buffer, GFBuffer sig_buffer,
+ void Verify(const GFBuffer& in_buffer, const GFBuffer& sig_buffer,
const GpgOperationCallback& cb);
/**
+ * @brief
+ *
+ * @param in_buffer
+ * @param sig_buffer
+ * @param cb
+ * @return std::tuple<GpgError, DataObjectPtr>
+ */
+ auto VerifySync(const GFBuffer& in_buffer, const GFBuffer& sig_buffer)
+ -> std::tuple<GpgError, DataObjectPtr>;
+
+ /**
* @brief Call the interface provided by gpgme for signing operation
*
* The signing modes are as follows:
@@ -141,8 +196,22 @@ class GPGFRONTEND_CORE_EXPORT GpgBasicOperator
* @param result the result of the operation
* @return error code
*/
- void Sign(KeyArgsList signers, GFBuffer in_buffer, GpgSignMode mode,
- bool ascii, const GpgOperationCallback& cb);
+ void Sign(const KeyArgsList& signers, const GFBuffer& in_buffer,
+ GpgSignMode mode, bool ascii, const GpgOperationCallback& cb);
+
+ /**
+ * @brief
+ *
+ * @param signers
+ * @param in_buffer
+ * @param mode
+ * @param ascii
+ * @param cb
+ * @return std::tuple<GpgError, DataObjectPtr>
+ */
+ auto SignSync(const KeyArgsList& signers, const GFBuffer& in_buffer,
+ GpgSignMode mode, bool ascii)
+ -> std::tuple<GpgError, DataObjectPtr>;
/**
* @brief Set the private key for signatures, this operation is a global
diff --git a/src/core/function/gpg/GpgContext.cpp b/src/core/function/gpg/GpgContext.cpp
index 104e254f..6523386c 100644
--- a/src/core/function/gpg/GpgContext.cpp
+++ b/src/core/function/gpg/GpgContext.cpp
@@ -94,16 +94,19 @@ class GpgContext::Impl {
int fd) -> gpgme_error_t {
size_t res;
QString pass = "abcdefg\n";
- auto pass_len = pass.size();
+ auto passpahrase_size = pass.size();
size_t off = 0;
do {
- res = gpgme_io_write(fd, &pass[off], pass_len - off);
+ res = gpgme_io_write(fd, &pass[off], passpahrase_size - off);
if (res > 0) off += res;
- } while (res > 0 && off != pass_len);
+ } while (res > 0 && off != passpahrase_size);
- return off == pass_len ? 0 : gpgme_error_from_errno(errno);
+ res += gpgme_io_write(fd, "\n", 1);
+ return res == passpahrase_size + 1
+ ? 0
+ : gpgme_error_from_errno(GPG_ERR_CANCELED);
}
static auto CustomPassphraseCb(void *hook, const char *uid_hint,
diff --git a/src/core/function/gpg/GpgFileOpera.cpp b/src/core/function/gpg/GpgFileOpera.cpp
index e3d47cf6..94a08c76 100644
--- a/src/core/function/gpg/GpgFileOpera.cpp
+++ b/src/core/function/gpg/GpgFileOpera.cpp
@@ -45,7 +45,7 @@ constexpr ssize_t kDataExchangerSize = 8192;
GpgFileOpera::GpgFileOpera(int channel)
: SingletonFunctionObject<GpgFileOpera>(channel) {}
-void GpgFileOpera::EncryptFile(std::vector<GpgKey> keys, const QString& in_path,
+void GpgFileOpera::EncryptFile(const KeyArgsList& keys, const QString& in_path,
bool ascii, const QString& out_path,
const GpgOperationCallback& cb) {
RunGpgOperaAsync(
@@ -69,7 +69,32 @@ void GpgFileOpera::EncryptFile(std::vector<GpgKey> keys, const QString& in_path,
cb, "gpgme_op_encrypt", "2.1.0");
}
-void GpgFileOpera::EncryptDirectory(std::vector<GpgKey> keys,
+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;
+ },
+ "gpgme_op_encrypt", "2.1.0");
+}
+
+void GpgFileOpera::EncryptDirectory(const KeyArgsList& keys,
const QString& in_path, bool ascii,
const QString& out_path,
const GpgOperationCallback& cb) {
@@ -122,6 +147,24 @@ void GpgFileOpera::DecryptFile(const QString& in_path, const QString& out_path,
cb, "gpgme_op_decrypt", "2.1.0");
}
+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;
+ },
+ "gpgme_op_decrypt", "2.1.0");
+}
+
void GpgFileOpera::DecryptArchive(const QString& in_path,
const QString& out_path,
const GpgOperationCallback& cb) {
@@ -148,7 +191,7 @@ void GpgFileOpera::DecryptArchive(const QString& in_path,
cb, "gpgme_op_decrypt", "2.1.0");
}
-void GpgFileOpera::SignFile(KeyArgsList keys, const QString& in_path,
+void GpgFileOpera::SignFile(const KeyArgsList& keys, const QString& in_path,
bool ascii, const QString& out_path,
const GpgOperationCallback& cb) {
RunGpgOperaAsync(
@@ -173,6 +216,31 @@ void GpgFileOpera::SignFile(KeyArgsList keys, const QString& in_path,
cb, "gpgme_op_sign", "2.1.0");
}
+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().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;
+ },
+ "gpgme_op_sign", "2.1.0");
+}
+
void GpgFileOpera::VerifyFile(const QString& data_path,
const QString& sign_path,
const GpgOperationCallback& cb) {
@@ -200,7 +268,35 @@ void GpgFileOpera::VerifyFile(const QString& data_path,
cb, "gpgme_op_verify", "2.1.0");
}
-void GpgFileOpera::EncryptSignFile(KeyArgsList keys, KeyArgsList signer_keys,
+auto GpgFileOpera::VerifyFileSync(const QString& data_path,
+ const QString& sign_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;
+ },
+ "gpgme_op_verify", "2.1.0");
+}
+
+void GpgFileOpera::EncryptSignFile(const KeyArgsList& keys,
+ const KeyArgsList& signer_keys,
const QString& in_path, bool ascii,
const QString& out_path,
const GpgOperationCallback& cb) {
@@ -231,8 +327,40 @@ void GpgFileOpera::EncryptSignFile(KeyArgsList keys, KeyArgsList signer_keys,
cb, "gpgme_op_encrypt_sign", "2.1.0");
}
-void GpgFileOpera::EncryptSignDirectory(KeyArgsList keys,
- KeyArgsList signer_keys,
+auto GpgFileOpera::EncryptSignFileSync(const KeyArgsList& keys,
+ const KeyArgsList& signer_keys,
+ 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().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;
+ },
+ "gpgme_op_encrypt_sign", "2.1.0");
+}
+
+void GpgFileOpera::EncryptSignDirectory(const KeyArgsList& keys,
+ const KeyArgsList& signer_keys,
const QString& in_path, bool ascii,
const QString& out_path,
const GpgOperationCallback& cb) {
@@ -293,6 +421,29 @@ void GpgFileOpera::DecryptVerifyFile(const QString& in_path,
cb, "gpgme_op_decrypt_verify", "2.1.0");
}
+auto GpgFileOpera::DecryptVerifyFileSync(const QString& in_path,
+ const QString& out_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;
+ },
+ "gpgme_op_decrypt_verify", "2.1.0");
+}
+
void GpgFileOpera::DecryptVerifyArchive(const QString& in_path,
const QString& out_path,
const GpgOperationCallback& cb) {
@@ -343,6 +494,26 @@ void GpgFileOpera::EncryptFileSymmetric(const QString& in_path, bool ascii,
cb, "gpgme_op_encrypt_symmetric", "2.1.0");
}
+auto GpgFileOpera::EncryptFileSymmetricSync(const QString& in_path, bool ascii,
+ 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* 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;
+ },
+ "gpgme_op_encrypt_symmetric", "2.1.0");
+}
+
void GpgFileOpera::EncryptDerectorySymmetric(const QString& in_path, bool ascii,
const QString& out_path,
const GpgOperationCallback& cb) {
@@ -369,4 +540,33 @@ void GpgFileOpera::EncryptDerectorySymmetric(const QString& in_path, bool ascii,
GF_CORE_LOG_DEBUG("new archive 2 fd operation, err: {}", err);
});
}
+
+auto GpgFileOpera::EncryptDerectorySymmetricSync(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&) {
+ GF_CORE_LOG_DEBUG("new archive 2 fd operation, err: {}", err);
+ });
+
+ 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;
+ },
+ "gpgme_op_encrypt_symmetric", "2.1.0");
+}
+
} // 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 b015ebe9..d7c2d44c 100644
--- a/src/core/function/gpg/GpgFileOpera.h
+++ b/src/core/function/gpg/GpgFileOpera.h
@@ -61,7 +61,7 @@ class GPGFRONTEND_CORE_EXPORT GpgFileOpera
* @param channel Channel in context
* @return unsigned int error code
*/
- void EncryptFile(KeyArgsList keys, const QString& in_path, bool ascii,
+ void EncryptFile(const KeyArgsList& keys, const QString& in_path, bool ascii,
const QString& out_path, const GpgOperationCallback& cb);
/**
@@ -71,10 +71,23 @@ class GPGFRONTEND_CORE_EXPORT GpgFileOpera
* @param in_path
* @param ascii
* @param out_path
+ * @return std::tuple<GpgError, DataObjectPtr>
+ */
+ auto EncryptFileSync(const KeyArgsList& keys, const QString& in_path,
+ bool ascii, const QString& out_path)
+ -> std::tuple<GpgError, DataObjectPtr>;
+
+ /**
+ * @brief
+ *
+ * @param keys
+ * @param in_path
+ * @param ascii
+ * @param out_path
* @param cb
*/
- void EncryptDirectory(KeyArgsList keys, const QString& in_path, bool ascii,
- const QString& out_path,
+ void EncryptDirectory(const KeyArgsList& keys, const QString& in_path,
+ bool ascii, const QString& out_path,
const GpgOperationCallback& cb);
/**
@@ -98,6 +111,18 @@ class GPGFRONTEND_CORE_EXPORT GpgFileOpera
* @param out_path
* @param cb
*/
+ auto EncryptFileSymmetricSync(const QString& in_path, bool ascii,
+ const QString& out_path)
+ -> std::tuple<GpgError, DataObjectPtr>;
+
+ /**
+ * @brief
+ *
+ * @param in_path
+ * @param ascii
+ * @param out_path
+ * @param cb
+ */
void EncryptDerectorySymmetric(const QString& in_path, bool ascii,
const QString& out_path,
const GpgOperationCallback& cb);
@@ -106,6 +131,17 @@ class GPGFRONTEND_CORE_EXPORT GpgFileOpera
* @brief
*
* @param in_path
+ * @param ascii
+ * @param out_path
+ */
+ auto EncryptDerectorySymmetricSync(const QString& in_path, bool ascii,
+ const QString& out_path)
+ -> std::tuple<GpgError, DataObjectPtr>;
+
+ /**
+ * @brief
+ *
+ * @param in_path
* @param out_path
* @param result
* @return GpgError
@@ -119,6 +155,17 @@ class GPGFRONTEND_CORE_EXPORT GpgFileOpera
* @param in_path
* @param out_path
* @param cb
+ * @return std::tuple<GpgError, DataObjectPtr>
+ */
+ auto DecryptFileSync(const QString& in_path, const QString& out_path)
+ -> std::tuple<GpgError, DataObjectPtr>;
+
+ /**
+ * @brief
+ *
+ * @param in_path
+ * @param out_path
+ * @param cb
*/
void DecryptArchive(const QString& in_path, const QString& out_path,
const GpgOperationCallback& cb);
@@ -133,10 +180,23 @@ class GPGFRONTEND_CORE_EXPORT GpgFileOpera
* @param channel
* @return GpgError
*/
- void SignFile(KeyArgsList keys, const QString& in_path, bool ascii,
+ void SignFile(const KeyArgsList& keys, const QString& in_path, bool ascii,
const QString& out_path, const GpgOperationCallback& cb);
/**
+ * @brief
+ *
+ * @param keys
+ * @param in_path
+ * @param ascii
+ * @param out_path
+ * @return std::tuple<GpgError, DataObjectPtr>
+ */
+ auto SignFileSync(const KeyArgsList& keys, const QString& in_path, bool ascii,
+ const QString& out_path)
+ -> std::tuple<GpgError, DataObjectPtr>;
+
+ /**
* @brief Verify file with public key
*
* @param data_path The path where the enter file is located
@@ -151,6 +211,16 @@ class GPGFRONTEND_CORE_EXPORT GpgFileOpera
/**
* @brief
*
+ * @param data_path
+ * @param sign_path
+ * @return std::tuple<GpgError, DataObjectPtr>
+ */
+ auto VerifyFileSync(const QString& data_path, const QString& sign_path)
+ -> std::tuple<GpgError, DataObjectPtr>;
+
+ /**
+ * @brief
+ *
* @param keys
* @param signer_keys
* @param in_path
@@ -158,7 +228,7 @@ class GPGFRONTEND_CORE_EXPORT GpgFileOpera
* @param out_path
* @param cb
*/
- void EncryptSignFile(KeyArgsList keys, KeyArgsList signer_keys,
+ void EncryptSignFile(const KeyArgsList& keys, const KeyArgsList& signer_keys,
const QString& in_path, bool ascii,
const QString& out_path, const GpgOperationCallback& cb);
@@ -170,9 +240,25 @@ class GPGFRONTEND_CORE_EXPORT GpgFileOpera
* @param in_path
* @param ascii
* @param out_path
+ */
+ auto EncryptSignFileSync(const KeyArgsList& keys,
+ const KeyArgsList& signer_keys,
+ const QString& in_path, bool ascii,
+ const QString& out_path)
+ -> std::tuple<GpgError, DataObjectPtr>;
+
+ /**
+ * @brief
+ *
+ * @param keys
+ * @param signer_keys
+ * @param in_path
+ * @param ascii
+ * @param out_path
* @param cb
*/
- void EncryptSignDirectory(KeyArgsList keys, KeyArgsList signer_keys,
+ void EncryptSignDirectory(const KeyArgsList& keys,
+ const KeyArgsList& signer_keys,
const QString& in_path, bool ascii,
const QString& out_path,
const GpgOperationCallback& cb);
@@ -194,6 +280,15 @@ class GPGFRONTEND_CORE_EXPORT GpgFileOpera
*
* @param in_path
* @param out_path
+ */
+ auto DecryptVerifyFileSync(const QString& in_path, const QString& out_path)
+ -> std::tuple<GpgError, DataObjectPtr>;
+
+ /**
+ * @brief
+ *
+ * @param in_path
+ * @param out_path
* @param cb
*/
void DecryptVerifyArchive(const QString& in_path, const QString& out_path,
diff --git a/src/core/function/gpg/GpgKeyOpera.cpp b/src/core/function/gpg/GpgKeyOpera.cpp
index 9a722c0b..5f8daf81 100644
--- a/src/core/function/gpg/GpgKeyOpera.cpp
+++ b/src/core/function/gpg/GpgKeyOpera.cpp
@@ -161,14 +161,12 @@ void GpgKeyOpera::GenerateKey(const std::shared_ptr<GenKeyInfo>& params,
const GpgOperationCallback& callback) {
RunGpgOperaAsync(
[&ctx = ctx_, params](const DataObjectPtr& data_object) -> GpgError {
- auto userid_utf8 = params->GetUserid();
- const char* userid = userid_utf8.toUtf8();
- auto algo_utf8 = params->GetAlgo() + params->GetKeySizeStr();
+ auto userid = params->GetUserid();
+ auto algo = params->GetAlgo() + params->GetKeySizeStr();
GF_CORE_LOG_DEBUG("params: {} {}", params->GetAlgo(),
params->GetKeySizeStr());
- auto algo = algo_utf8.toUtf8();
unsigned long expires =
QDateTime::currentDateTime().secsTo(params->GetExpireTime());
@@ -182,10 +180,10 @@ void GpgKeyOpera::GenerateKey(const std::shared_ptr<GenKeyInfo>& params,
if (params->IsNonExpired()) flags |= GPGME_CREATE_NOEXPIRE;
if (params->IsNoPassPhrase()) flags |= GPGME_CREATE_NOPASSWD;
- GF_CORE_LOG_DEBUG("key generation args: {}", userid, algo, expires,
- flags);
- err = gpgme_op_createkey(ctx.DefaultContext(), userid, algo, 0, expires,
- nullptr, flags);
+ GF_CORE_LOG_DEBUG("key generation args: {} {} {} {}", userid, algo,
+ expires, flags);
+ 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{
@@ -199,23 +197,96 @@ void GpgKeyOpera::GenerateKey(const std::shared_ptr<GenKeyInfo>& params,
callback, "gpgme_op_createkey", "2.1.0");
}
-/**
- * Generate a new subkey of a certain key pair
- * @param key target key pair
- * @param params opera args
- * @return error info
- */
+auto GpgKeyOpera::GenerateKeySync(const std::shared_ptr<GenKeyInfo>& params)
+ -> std::tuple<GpgError, DataObjectPtr> {
+ return RunGpgOperaSync(
+ [=, &ctx = ctx_](const DataObjectPtr& data_object) -> GpgError {
+ auto userid = params->GetUserid();
+ auto algo = params->GetAlgo() + params->GetKeySizeStr();
+
+ GF_CORE_LOG_DEBUG("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;
+
+ GF_CORE_LOG_DEBUG("key generation args: {} {} {} {}", userid, algo,
+ expires, flags);
+ 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);
+ },
+ "gpgme_op_createkey", "2.1.0");
+}
+
void GpgKeyOpera::GenerateSubkey(const GpgKey& key,
const std::shared_ptr<GenKeyInfo>& params,
const GpgOperationCallback& callback) {
RunGpgOperaAsync(
- [key, &ctx = ctx_, params](const DataObjectPtr&) -> GpgError {
+ [key, &ctx = ctx_, params](const DataObjectPtr& data_object) -> GpgError {
+ if (!params->IsSubKey()) return GPG_ERR_CANCELED;
+
+ GF_CORE_LOG_DEBUG("generate subkey algo {}, key size {}",
+ params->GetAlgo(), 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;
+
+ GF_CORE_LOG_DEBUG("subkey generation args: {} {} {} {}", key.GetId(),
+ algo, expires, flags);
+ auto err = gpgme_op_createsubkey(ctx.DefaultContext(),
+ static_cast<gpgme_key_t>(key),
+ algo.toUtf8(), 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);
+ },
+ callback, "gpgme_op_createsubkey", "2.1.13");
+}
+
+auto GpgKeyOpera::GenerateSubkeySync(const GpgKey& key,
+ const std::shared_ptr<GenKeyInfo>& params)
+ -> std::tuple<GpgError, DataObjectPtr> {
+ return RunGpgOperaSync(
+ [key, &ctx = ctx_, params](const DataObjectPtr& data_object) -> GpgError {
if (!params->IsSubKey()) return GPG_ERR_CANCELED;
GF_CORE_LOG_DEBUG("generate subkey algo {} key size {}",
params->GetAlgo(), params->GetKeySizeStr());
- auto algo = (params->GetAlgo() + params->GetKeySizeStr()).toUtf8();
+ auto algo = params->GetAlgo() + params->GetKeySizeStr();
unsigned long expires =
QDateTime::currentDateTime().secsTo(params->GetExpireTime());
unsigned int flags = 0;
@@ -231,11 +302,19 @@ void GpgKeyOpera::GenerateSubkey(const GpgKey& key,
flags);
auto err = gpgme_op_createsubkey(ctx.DefaultContext(),
- static_cast<gpgme_key_t>(key), algo, 0,
- expires, flags);
+ static_cast<gpgme_key_t>(key),
+ algo.toUtf8(), 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);
},
- callback, "gpgme_op_createsubkey", "2.1.13");
+ "gpgme_op_createsubkey", "2.1.13");
}
void GpgKeyOpera::GenerateKeyWithSubkey(
@@ -273,6 +352,11 @@ void GpgKeyOpera::GenerateKeyWithSubkey(
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().GetKey(genkey_result.GetFingerprint());
if (!key.IsGood()) {
@@ -281,8 +365,6 @@ void GpgKeyOpera::GenerateKeyWithSubkey(
return err;
}
- if (subkey_params == nullptr || !subkey_params->IsSubKey()) return err;
-
GF_CORE_LOG_DEBUG(
"try to generate subkey of key: {}, algo {} key size {}",
key.GetId(), subkey_params->GetAlgo(),
@@ -320,6 +402,91 @@ void GpgKeyOpera::GenerateKeyWithSubkey(
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)
+ -> std::tuple<GpgError, DataObjectPtr> {
+ return RunGpgOperaSync(
+ [&ctx = ctx_, params,
+ subkey_params](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;
+
+ GF_CORE_LOG_DEBUG("key generation args: {}", userid, algo, expires,
+ flags);
+ err = gpgme_op_createkey(ctx.DefaultContext(), userid, algo, 0, expires,
+ nullptr, flags);
+
+ 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().GetKey(genkey_result.GetFingerprint());
+ if (!key.IsGood()) {
+ GF_CORE_LOG_ERROR("cannot get key which has been generate, fpr: {}",
+ genkey_result.GetFingerprint());
+ return err;
+ }
+
+ GF_CORE_LOG_DEBUG(
+ "try to generate subkey of key: {}, algo {} key size {}",
+ key.GetId(), subkey_params->GetAlgo(),
+ 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;
+
+ GF_CORE_LOG_DEBUG("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);
+ },
+ "gpgme_op_createkey&gpgme_op_createsubkey", "2.1.0");
+}
+
void GpgKeyOpera::ModifyPassword(const GpgKey& key,
const GpgOperationCallback& callback) {
RunGpgOperaAsync(
diff --git a/src/core/function/gpg/GpgKeyOpera.h b/src/core/function/gpg/GpgKeyOpera.h
index a060af1a..6ffe437c 100644
--- a/src/core/function/gpg/GpgKeyOpera.h
+++ b/src/core/function/gpg/GpgKeyOpera.h
@@ -118,6 +118,14 @@ class GPGFRONTEND_CORE_EXPORT GpgKeyOpera
/**
* @brief
*
+ * @param params
+ */
+ auto GenerateKeySync(const std::shared_ptr<GenKeyInfo>& params)
+ -> std::tuple<GpgError, DataObjectPtr>;
+
+ /**
+ * @brief
+ *
* @param key
* @param params
* @return GpgFrontend::GpgError
@@ -129,6 +137,16 @@ class GPGFRONTEND_CORE_EXPORT GpgKeyOpera
/**
* @brief
*
+ * @param key
+ * @param params
+ */
+ auto GenerateSubkeySync(const GpgKey& key,
+ const std::shared_ptr<GenKeyInfo>& params)
+ -> std::tuple<GpgError, DataObjectPtr>;
+
+ /**
+ * @brief
+ *
* @param params
* @param subkey_params
* @param callback
@@ -137,6 +155,18 @@ class GPGFRONTEND_CORE_EXPORT GpgKeyOpera
const std::shared_ptr<GenKeyInfo>& subkey_params,
const GpgOperationCallback& callback);
+ /**
+ * @brief
+ *
+ * @param params
+ * @param subkey_params
+ * @param callback
+ */
+ auto GenerateKeyWithSubkeySync(
+ const std::shared_ptr<GenKeyInfo>& params,
+ const std::shared_ptr<GenKeyInfo>& subkey_params)
+ -> std::tuple<GpgError, DataObjectPtr>;
+
private:
GpgContext& ctx_ =
GpgContext::GetInstance(SingletonFunctionObject::GetChannel()); ///<
generated by cgit v1.2.3 (git 2.25.1) at 2025-04-28 10:21:59 +0000