aboutsummaryrefslogtreecommitdiffstats
path: root/src/test/core/GpgCoreTestBasicOpera.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/test/core/GpgCoreTestBasicOpera.cpp')
-rw-r--r--src/test/core/GpgCoreTestBasicOpera.cpp263
1 files changed, 145 insertions, 118 deletions
diff --git a/src/test/core/GpgCoreTestBasicOpera.cpp b/src/test/core/GpgCoreTestBasicOpera.cpp
index 8eef1565..de6d6805 100644
--- a/src/test/core/GpgCoreTestBasicOpera.cpp
+++ b/src/test/core/GpgCoreTestBasicOpera.cpp
@@ -34,6 +34,8 @@
#include "core/function/result_analyse/GpgDecryptResultAnalyse.h"
#include "core/model/GpgDecryptResult.h"
#include "core/model/GpgEncryptResult.h"
+#include "core/model/GpgSignResult.h"
+#include "core/model/GpgVerifyResult.h"
#include "core/utils/GpgUtils.h"
namespace GpgFrontend::Test {
@@ -41,11 +43,9 @@ namespace GpgFrontend::Test {
TEST_F(GpgCoreTest, CoreEncryptDecrTest) {
auto encrypt_key = GpgKeyGetter::GetInstance().GetPubkey(
"E87C6A2D8D95C818DE93B3AE6A2764F8298DEB29");
- auto encrypt_text = GFBuffer("Hello GpgFrontend!");
- auto const keys = std::vector<GpgKey>{encrypt_key};
GpgBasicOperator::GetInstance().Encrypt(
- keys, encrypt_text, true,
+ {encrypt_key}, GFBuffer("Hello GpgFrontend!"), true,
[](GpgError err, const DataObjectPtr& data_obj) {
ASSERT_TRUE((data_obj->Check<GpgEncryptResult, GFBuffer>()));
auto result = ExtractParams<GpgEncryptResult>(data_obj, 0);
@@ -53,9 +53,8 @@ TEST_F(GpgCoreTest, CoreEncryptDecrTest) {
ASSERT_TRUE(result.InvalidRecipients().empty());
ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
- GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
- .Decrypt(encr_out_buffer, [](GpgError err,
- const DataObjectPtr& data_obj) {
+ GpgBasicOperator::GetInstance().Decrypt(
+ encr_out_buffer, [](GpgError err, const DataObjectPtr& data_obj) {
auto d_result = ExtractParams<GpgDecryptResult>(data_obj, 0);
auto decr_out_buffer = ExtractParams<GFBuffer>(data_obj, 1);
ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
@@ -67,6 +66,28 @@ TEST_F(GpgCoreTest, CoreEncryptDecrTest) {
});
}
+TEST_F(GpgCoreTest, CoreEncryptSymmetricDecrTest) {
+ auto encrypt_text = GFBuffer("Hello GpgFrontend!");
+
+ GpgBasicOperator::GetInstance().EncryptSymmetric(
+ encrypt_text, true, [](GpgError err, const DataObjectPtr& data_obj) {
+ ASSERT_TRUE((data_obj->Check<GpgEncryptResult, GFBuffer>()));
+ auto result = ExtractParams<GpgEncryptResult>(data_obj, 0);
+ auto encr_out_buffer = ExtractParams<GFBuffer>(data_obj, 1);
+ ASSERT_TRUE(result.InvalidRecipients().empty());
+ ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+
+ GpgBasicOperator::GetInstance().Decrypt(
+ encr_out_buffer, [](GpgError err, const DataObjectPtr& data_obj) {
+ auto d_result = ExtractParams<GpgDecryptResult>(data_obj, 0);
+ auto decr_out_buffer = ExtractParams<GFBuffer>(data_obj, 1);
+ ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+ ASSERT_TRUE(d_result.Recipients().empty());
+ ASSERT_EQ(decr_out_buffer, GFBuffer("Hello GpgFrontend!"));
+ });
+ });
+}
+
TEST_F(GpgCoreTest, CoreEncryptDecrTest_KeyNotFound_1) {
auto encr_out_data = GFBuffer(
"-----BEGIN PGP MESSAGE-----\n"
@@ -81,8 +102,8 @@ TEST_F(GpgCoreTest, CoreEncryptDecrTest_KeyNotFound_1) {
"=8n2H\n"
"-----END PGP MESSAGE-----");
- GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
- .Decrypt(encr_out_data, [=](GpgError err, const DataObjectPtr& data_obj) {
+ GpgBasicOperator::GetInstance().Decrypt(
+ encr_out_data, [=](GpgError err, const DataObjectPtr& data_obj) {
auto d_result = ExtractParams<GpgDecryptResult>(data_obj, 0);
auto decr_out_buffer = ExtractParams<GFBuffer>(data_obj, 1);
ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_SECKEY);
@@ -105,137 +126,143 @@ TEST_F(GpgCoreTest, CoreEncryptDecrTest_KeyNotFound_ResultAnalyse) {
"=8n2H\n"
"-----END PGP MESSAGE-----");
- GpgDecrResult d_result;
- ByteArrayPtr decr_out_data;
- GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
- .Decrypt(encr_out_data, [=](GpgError err, const DataObjectPtr& data_obj) {
+ GpgBasicOperator::GetInstance().Decrypt(
+ encr_out_data, [=](GpgError err, const DataObjectPtr& data_obj) {
auto d_result = ExtractParams<GpgDecryptResult>(data_obj, 0);
auto decr_out_buffer = ExtractParams<GFBuffer>(data_obj, 1);
ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_SECKEY);
ASSERT_FALSE(d_result.Recipients().empty());
ASSERT_EQ(d_result.Recipients()[0].keyid, "A50CFD2F6C677D8C");
- // GpgDecryptResultAnalyse analyse{err, d_result};
- // analyse.Analyse();
- // ASSERT_EQ(analyse.GetStatus(), -1);
- // ASSERT_FALSE(analyse.GetResultReport().empty());
+ GpgDecryptResultAnalyse analyse{err, d_result};
+ analyse.Analyse();
+ ASSERT_EQ(analyse.GetStatus(), -1);
+ ASSERT_FALSE(analyse.GetResultReport().empty());
});
}
TEST_F(GpgCoreTest, CoreSignVerifyNormalTest) {
- auto encrypt_key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
- .GetPubkey("467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
- ByteArray sign_text = "Hello GpgFrontend!";
- ByteArrayPtr sign_out_data;
- GpgSignResult s_result;
- KeyListPtr keys = std::make_unique<KeyArgsList>();
- keys->push_back(std::move(encrypt_key));
- auto err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
- .Sign(std::move(keys), sign_text, sign_out_data,
- GPGME_SIG_MODE_NORMAL, s_result);
- ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
- ASSERT_EQ(s_result->invalid_signers, nullptr);
-
- GpgVerifyResult v_result;
- ByteArrayPtr sign_buff = nullptr;
- err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
- .Verify(*sign_out_data, sign_buff, v_result);
- ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
- ASSERT_NE(v_result->signatures, nullptr);
- ASSERT_EQ(std::string(v_result->signatures->fpr),
- "467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
- ASSERT_EQ(v_result->signatures->next, nullptr);
+ auto sign_key = GpgKeyGetter::GetInstance().GetPubkey(
+ "467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
+ auto sign_text = GFBuffer("Hello GpgFrontend!");
+
+ GpgBasicOperator::GetInstance().Sign(
+ {sign_key}, sign_text, GPGME_SIG_MODE_NORMAL, true,
+ [](GpgError err, const DataObjectPtr& data_obj) {
+ ASSERT_TRUE((data_obj->Check<GpgSignResult, GFBuffer>()));
+ auto result = ExtractParams<GpgSignResult>(data_obj, 0);
+ auto sign_out_buffer = ExtractParams<GFBuffer>(data_obj, 1);
+ ASSERT_TRUE(result.InvalidSigners().empty());
+ ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+
+ GpgBasicOperator::GetInstance().Verify(
+ sign_out_buffer, GFBuffer(),
+ [](GpgError err, const DataObjectPtr& data_obj) {
+ auto d_result = ExtractParams<GpgVerifyResult>(data_obj, 0);
+ ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+ ASSERT_FALSE(d_result.GetSignature().empty());
+ ASSERT_EQ(d_result.GetSignature().at(0),
+ "467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
+ });
+ });
}
TEST_F(GpgCoreTest, CoreSignVerifyDetachTest) {
- auto encrypt_key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
- .GetPubkey("467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
- ByteArray sign_text = "Hello GpgFrontend!";
- ByteArrayPtr sign_out_data;
- GpgSignResult s_result;
- KeyListPtr keys = std::make_unique<KeyArgsList>();
- keys->push_back(std::move(encrypt_key));
- auto err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
- .Sign(std::move(keys), sign_text, sign_out_data,
- GPGME_SIG_MODE_DETACH, s_result);
- ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
- ASSERT_EQ(s_result->invalid_signers, nullptr);
-
- GpgVerifyResult v_result;
- err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
- .Verify(sign_text, sign_out_data, v_result);
- ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
- ASSERT_NE(v_result->signatures, nullptr);
- ASSERT_EQ(std::string(v_result->signatures->fpr),
- "467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
- ASSERT_EQ(v_result->signatures->next, nullptr);
+ auto sign_key = GpgKeyGetter::GetInstance().GetPubkey(
+ "467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
+ auto sign_text = GFBuffer("Hello GpgFrontend!");
+
+ GpgBasicOperator::GetInstance().Sign(
+ {sign_key}, sign_text, GPGME_SIG_MODE_DETACH, true,
+ [=](GpgError err, const DataObjectPtr& data_obj) {
+ ASSERT_TRUE((data_obj->Check<GpgSignResult, GFBuffer>()));
+ auto result = ExtractParams<GpgSignResult>(data_obj, 0);
+ auto sign_out_buffer = ExtractParams<GFBuffer>(data_obj, 1);
+ ASSERT_TRUE(result.InvalidSigners().empty());
+ ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+
+ GpgBasicOperator::GetInstance().Verify(
+ sign_text, sign_out_buffer,
+ [](GpgError err, const DataObjectPtr& data_obj) {
+ auto d_result = ExtractParams<GpgVerifyResult>(data_obj, 0);
+ ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+ ASSERT_FALSE(d_result.GetSignature().empty());
+ ASSERT_EQ(d_result.GetSignature().at(0),
+ "467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
+ });
+ });
}
TEST_F(GpgCoreTest, CoreSignVerifyClearTest) {
- auto sign_key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
- .GetKey("467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
- ByteArray sign_text = "Hello GpgFrontend!";
- ByteArrayPtr sign_out_data;
- GpgSignResult s_result;
- KeyListPtr keys = std::make_unique<KeyArgsList>();
- keys->push_back(std::move(sign_key));
- auto err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
- .Sign(std::move(keys), sign_text, sign_out_data,
- GPGME_SIG_MODE_CLEAR, s_result);
- ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
- ASSERT_EQ(s_result->invalid_signers, nullptr);
-
- GpgVerifyResult v_result;
- ByteArrayPtr sign_buff = nullptr;
- err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
- .Verify(*sign_out_data, sign_buff, v_result);
- ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
- ASSERT_NE(v_result->signatures, nullptr);
- ASSERT_EQ(std::string(v_result->signatures->fpr),
- "467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
- ASSERT_EQ(v_result->signatures->next, nullptr);
+ auto sign_key = GpgKeyGetter::GetInstance().GetPubkey(
+ "467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
+ auto sign_text = GFBuffer("Hello GpgFrontend!");
+
+ GpgBasicOperator::GetInstance().Sign(
+ {sign_key}, sign_text, GPGME_SIG_MODE_CLEAR, true,
+ [](GpgError err, const DataObjectPtr& data_obj) {
+ ASSERT_TRUE((data_obj->Check<GpgSignResult, GFBuffer>()));
+ auto result = ExtractParams<GpgSignResult>(data_obj, 0);
+ auto sign_out_buffer = ExtractParams<GFBuffer>(data_obj, 1);
+ ASSERT_TRUE(result.InvalidSigners().empty());
+ ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+
+ GpgBasicOperator::GetInstance().Verify(
+ sign_out_buffer, GFBuffer(),
+ [](GpgError err, const DataObjectPtr& data_obj) {
+ auto verify_reult = ExtractParams<GpgVerifyResult>(data_obj, 0);
+ ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+ ASSERT_FALSE(verify_reult.GetSignature().empty());
+ ASSERT_EQ(verify_reult.GetSignature().at(0),
+ "467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
+ });
+ });
}
TEST_F(GpgCoreTest, CoreEncryptSignDecrVerifyTest) {
- auto encrypt_key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
- .GetPubkey("467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
- auto sign_key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
- .GetKey("8933EB283A18995F45D61DAC021D89771B680FFB");
- // Question?
- // ASSERT_FALSE(encrypt_key.is_private_key());
+ auto encrypt_key = GpgKeyGetter::GetInstance().GetPubkey(
+ "467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
+ auto sign_key = GpgKeyGetter::GetInstance().GetKey(
+ "8933EB283A18995F45D61DAC021D89771B680FFB");
+ auto encrypt_text = GFBuffer("Hello GpgFrontend!");
+
ASSERT_TRUE(sign_key.IsPrivateKey());
ASSERT_TRUE(sign_key.IsHasActualSigningCapability());
- ByteArray encrypt_text = "Hello GpgFrontend!";
- ByteArrayPtr encr_out_data;
- GpgEncrResult e_result;
- GpgSignResult s_result;
-
- KeyListPtr keys = std::make_unique<KeyArgsList>();
- KeyListPtr sign_keys = std::make_unique<KeyArgsList>();
-
- keys->push_back(std::move(encrypt_key));
- sign_keys->push_back(std::move(sign_key));
-
- auto err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
- .EncryptSign(std::move(keys), std::move(sign_keys),
- encrypt_text, encr_out_data, e_result, s_result);
- ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
- ASSERT_EQ(e_result->invalid_recipients, nullptr);
- ASSERT_EQ(s_result->invalid_signers, nullptr);
-
- GpgDecrResult d_result;
- GpgVerifyResult v_result;
- ByteArrayPtr decr_out_data = nullptr;
- err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
- .DecryptVerify(*encr_out_data, decr_out_data, d_result, v_result);
- ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
- ASSERT_NE(d_result->recipients, nullptr);
- ASSERT_EQ(std::string(d_result->recipients->keyid), "F89C95A05088CC93");
- ASSERT_EQ(*decr_out_data, encrypt_text);
- ASSERT_NE(v_result->signatures, nullptr);
- ASSERT_EQ(std::string(v_result->signatures->fpr),
- "8933EB283A18995F45D61DAC021D89771B680FFB");
- ASSERT_EQ(v_result->signatures->next, nullptr);
+
+ GpgBasicOperator::GetInstance().EncryptSign(
+ {encrypt_key}, {sign_key}, encrypt_text, true,
+ [](GpgError err, const DataObjectPtr& data_obj) {
+ ASSERT_TRUE(
+ (data_obj->Check<GpgEncryptResult, GpgSignResult, GFBuffer>()));
+ auto encr_result = ExtractParams<GpgEncryptResult>(data_obj, 0);
+ auto sign_result = ExtractParams<GpgSignResult>(data_obj, 1);
+ auto encr_out_buffer = ExtractParams<GFBuffer>(data_obj, 2);
+ ASSERT_TRUE(encr_result.InvalidRecipients().empty());
+ ASSERT_TRUE(sign_result.InvalidSigners().empty());
+ ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+
+ GpgBasicOperator::GetInstance().DecryptVerify(
+ encr_out_buffer, [](GpgError err, const DataObjectPtr& data_obj) {
+ ASSERT_TRUE(
+ (data_obj
+ ->Check<GpgDecryptResult, GpgVerifyResult, GFBuffer>()));
+ auto decrypt_result =
+ ExtractParams<GpgDecryptResult>(data_obj, 0);
+ auto verify_reult = ExtractParams<GpgVerifyResult>(data_obj, 1);
+ auto decr_out_buffer = ExtractParams<GFBuffer>(data_obj, 2);
+
+ ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+
+ ASSERT_FALSE(decrypt_result.Recipients().empty());
+ ASSERT_EQ(decr_out_buffer, GFBuffer("Hello GpgFrontend!"));
+
+ ASSERT_EQ(decrypt_result.Recipients()[0].keyid,
+ "F89C95A05088CC93");
+ ASSERT_FALSE(verify_reult.GetSignature().empty());
+ ASSERT_EQ(verify_reult.GetSignature().at(0),
+ "8933EB283A18995F45D61DAC021D89771B680FFB");
+ });
+ });
}
} // namespace GpgFrontend::Test
generated by cgit v1.2.3 (git 2.25.1) at 2025-04-27 23:31:27 +0000