Merge branch 'develop'

5 files changed, 442 insertions, 322 deletions

diff --git a/src/test/core/GpgCoreTestBasicOpera.cpp b/src/test/core/GpgCoreTestBasicOpera.cpp
index 2e675766..a7bdfead 100644
--- a/src/test/core/GpgCoreTestBasicOpera.cpp
+++ b/src/test/core/GpgCoreTestBasicOpera.cpp
@@ -171,7 +171,7 @@ TEST_F(GpgCoreTest, CoreSignVerifyNormalTest) {
       GpgBasicOperator::GetInstance().VerifySync(sign_out_buffer, GFBuffer());
 
   ASSERT_EQ(CheckGpgError(err_0), GPG_ERR_NO_ERROR);
-  ASSERT_TRUE((data_object_0->Check<GpgVerifyResult>()));
+  ASSERT_TRUE((data_object_0->Check<GpgVerifyResult, GFBuffer>()));
   auto verify_result = ExtractParams<GpgVerifyResult>(data_object_0, 0);
   ASSERT_FALSE(verify_result.GetSignature().empty());
   ASSERT_EQ(verify_result.GetSignature().at(0).GetFingerprint(),
@@ -198,7 +198,7 @@ TEST_F(GpgCoreTest, CoreSignVerifyDetachTest) {
       GpgBasicOperator::GetInstance().VerifySync(sign_text, sign_out_buffer);
 
   ASSERT_EQ(CheckGpgError(err_0), GPG_ERR_NO_ERROR);
-  ASSERT_TRUE((data_object_0->Check<GpgVerifyResult>()));
+  ASSERT_TRUE((data_object_0->Check<GpgVerifyResult, GFBuffer>()));
   auto verify_result = ExtractParams<GpgVerifyResult>(data_object_0, 0);
   ASSERT_FALSE(verify_result.GetSignature().empty());
   ASSERT_EQ(verify_result.GetSignature().at(0).GetFingerprint(),
@@ -241,7 +241,7 @@ TEST_F(GpgCoreTest, CoreEncryptSignDecrVerifyTest) {
   auto encrypt_text = GFBuffer(QString("Hello GpgFrontend!"));
 
   ASSERT_TRUE(sign_key.IsPrivateKey());
-  ASSERT_TRUE(sign_key.IsHasActualSigningCapability());
+  ASSERT_TRUE(sign_key.IsHasActualSignCap());
 
   auto [err, data_object] = GpgBasicOperator::GetInstance().EncryptSignSync(
       {encrypt_key}, {sign_key}, encrypt_text, true);
diff --git a/src/test/core/GpgCoreTestFileBasicOpera.cpp b/src/test/core/GpgCoreTestFileBasicOpera.cpp
index 9a0c6a34..bb108499 100644
--- a/src/test/core/GpgCoreTestFileBasicOpera.cpp
+++ b/src/test/core/GpgCoreTestFileBasicOpera.cpp
@@ -232,7 +232,7 @@ TEST_F(GpgCoreTest, CoreFileEncryptSignDecrVerifyTest) {
   auto output_file = GetTempFilePath();
 
   ASSERT_TRUE(sign_key.IsPrivateKey());
-  ASSERT_TRUE(sign_key.IsHasActualSigningCapability());
+  ASSERT_TRUE(sign_key.IsHasActualSignCap());
 
   auto [err, data_object] = GpgFileOpera::GetInstance().EncryptSignFileSync(
       {encrypt_key}, {sign_key}, input_file, true, output_file);
@@ -279,7 +279,7 @@ TEST_F(GpgCoreTest, CoreFileEncryptSignDecrVerifyBinaryTest) {
   auto output_file = GetTempFilePath();
 
   ASSERT_TRUE(sign_key.IsPrivateKey());
-  ASSERT_TRUE(sign_key.IsHasActualSigningCapability());
+  ASSERT_TRUE(sign_key.IsHasActualSignCap());
 
   auto [err, data_object] = GpgFileOpera::GetInstance().EncryptSignFileSync(
       {encrypt_key}, {sign_key}, input_file, false, output_file);
diff --git a/src/test/core/GpgCoreTestKeyModel.cpp b/src/test/core/GpgCoreTestKeyModel.cpp
index 5d72956f..622d7009 100644
--- a/src/test/core/GpgCoreTestKeyModel.cpp
+++ b/src/test/core/GpgCoreTestKeyModel.cpp
@@ -69,14 +69,14 @@ TEST_F(GpgCoreTest, GpgKeyTest) {
   ASSERT_EQ(key.GetSubKeys()->size(), 2);
   ASSERT_EQ(key.GetUIDs()->size(), 1);
 
-  ASSERT_TRUE(key.IsHasCertificationCapability());
-  ASSERT_FALSE(key.IsHasEncryptionCapability());
-  ASSERT_TRUE(key.IsHasSigningCapability());
-  ASSERT_FALSE(key.IsHasAuthenticationCapability());
-  ASSERT_FALSE(key.IsHasActualCertificationCapability());
-  ASSERT_FALSE(key.IsHasActualEncryptionCapability());
-  ASSERT_FALSE(key.IsHasActualSigningCapability());
-  ASSERT_FALSE(key.IsHasActualAuthenticationCapability());
+  ASSERT_TRUE(key.IsHasCertCap());
+  ASSERT_FALSE(key.IsHasEncrCap());
+  ASSERT_TRUE(key.IsHasSignCap());
+  ASSERT_FALSE(key.IsHasAuthCap());
+  ASSERT_FALSE(key.IsHasActualCertCap());
+  ASSERT_FALSE(key.IsHasActualEncrCap());
+  ASSERT_FALSE(key.IsHasActualSignCap());
+  ASSERT_FALSE(key.IsHasActualAuthCap());
 
   ASSERT_EQ(key.GetName(), "GpgFrontendTest");
   ASSERT_TRUE(key.GetComment().isEmpty());
@@ -133,10 +133,10 @@ TEST_F(GpgCoreTest, GpgSubKeyTest) {
   ASSERT_EQ(sub_key.GetKeyLength(), 3072);
   ASSERT_EQ(sub_key.GetKeyAlgo(), "RSA3072");
   ASSERT_EQ(sub_key.GetPubkeyAlgo(), "RSA");
-  ASSERT_FALSE(sub_key.IsHasCertificationCapability());
-  ASSERT_FALSE(sub_key.IsHasAuthenticationCapability());
-  ASSERT_FALSE(sub_key.IsHasSigningCapability());
-  ASSERT_TRUE(sub_key.IsHasEncryptionCapability());
+  ASSERT_FALSE(sub_key.IsHasCertCap());
+  ASSERT_FALSE(sub_key.IsHasAuthCap());
+  ASSERT_FALSE(sub_key.IsHasSignCap());
+  ASSERT_TRUE(sub_key.IsHasEncrCap());
   ASSERT_EQ(sub_key.GetExpireTime(),
             QDateTime::fromString("2023-09-05T04:00:00Z", Qt::ISODate));
 
@@ -189,8 +189,8 @@ TEST_F(GpgCoreTest, GpgKeyGetterTest) {
   ASSERT_TRUE(key.IsGood());
   auto keys = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel).FetchKey();
 
-  EXPECT_GT(keys->size(), 0);
-  ASSERT_TRUE(find(keys->begin(), keys->end(), key) != keys->end());
+  EXPECT_GT(keys.size(), 0);
+  ASSERT_TRUE(std::find(keys.begin(), keys.end(), key) != keys.end());
 }
 
 }  // namespace GpgFrontend::Test
\ No newline at end of file
diff --git a/src/test/core/GpgCoreTestKeygen.cpp b/src/test/core/GpgCoreTestKeygen.cpp
index 9197e18e..a6c28219 100644
--- a/src/test/core/GpgCoreTestKeygen.cpp
+++ b/src/test/core/GpgCoreTestKeygen.cpp
@@ -29,26 +29,49 @@
 #include "GpgCoreTest.h"
 #include "core/function/gpg/GpgKeyGetter.h"
 #include "core/function/gpg/GpgKeyOpera.h"
-#include "core/model/GpgGenKeyInfo.h"
 #include "core/model/GpgGenerateKeyResult.h"
 #include "core/model/GpgKey.h"
+#include "core/model/GpgKeyGenerateInfo.h"
 #include "core/utils/GpgUtils.h"
 #include "core/utils/MemoryUtils.h"
 
 namespace GpgFrontend::Test {
 
+TEST_F(GpgCoreTest, SearchPrimaryKeyAlgoTest) {
+  auto [find, algo] = KeyGenerateInfo::SearchPrimaryKeyAlgo("rsa2048");
+  ASSERT_TRUE(find);
+  ASSERT_EQ(algo.Id(), "rsa2048");
+  ASSERT_EQ(algo.Id(), "rsa2048");
+  ASSERT_EQ(algo.Name(), "RSA");
+  ASSERT_EQ(algo.Type(), "RSA");
+  ASSERT_EQ(algo.KeyLength(), 2048);
+}
+
+TEST_F(GpgCoreTest, SearchSubKeyAlgoTest) {
+  auto [find, algo] = KeyGenerateInfo::SearchSubKeyAlgo("rsa2048");
+  ASSERT_TRUE(find);
+  ASSERT_EQ(algo.Id(), "rsa2048");
+  ASSERT_EQ(algo.Name(), "RSA");
+  ASSERT_EQ(algo.Type(), "RSA");
+  ASSERT_EQ(algo.KeyLength(), 2048);
+}
+
 TEST_F(GpgCoreTest, GenerateKeyRSA2048Test) {
-  auto keygen_info = SecureCreateSharedObject<GenKeyInfo>();
-  keygen_info->SetName("foo_0");
-  keygen_info->SetEmail("[email protected]");
-  keygen_info->SetComment("foobar");
-  keygen_info->SetAlgo("rsa");
-  keygen_info->SetKeyLength(2048);
-  keygen_info->SetNonExpired(true);
-  keygen_info->SetNonPassPhrase(true);
+  auto p_info = QSharedPointer<KeyGenerateInfo>::create();
+  p_info->SetName("foo_0");
+  p_info->SetEmail("[email protected]");
+  p_info->SetComment("foobar");
+
+  auto [found, algo] = KeyGenerateInfo::SearchPrimaryKeyAlgo("rsa2048");
+  ASSERT_TRUE(found);
+  ASSERT_EQ(algo.Id(), "rsa2048");
+  p_info->SetAlgo(algo);
+
+  p_info->SetNonExpired(true);
+  p_info->SetNonPassPhrase(true);
 
   auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
-                                .GenerateKeySync(keygen_info);
+                                .GenerateKeySync(p_info);
 
   ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
   ASSERT_EQ(data_object->GetObjectSize(), 1);
@@ -69,37 +92,41 @@ TEST_F(GpgCoreTest, GenerateKeyRSA2048Test) {
   ASSERT_EQ(key.GetPrimaryKeyLength(), 2048);
   ASSERT_EQ(key.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_TRUE(key.IsHasCertificationCapability());
-  ASSERT_TRUE(key.IsHasAuthenticationCapability());
-  ASSERT_TRUE(key.IsHasEncryptionCapability());
-  ASSERT_TRUE(key.IsHasSigningCapability());
+  ASSERT_TRUE(key.IsHasCertCap());
+  ASSERT_TRUE(key.IsHasAuthCap());
+  ASSERT_TRUE(key.IsHasEncrCap());
+  ASSERT_TRUE(key.IsHasSignCap());
 
-  ASSERT_TRUE(key.IsHasActualCertificationCapability());
-  ASSERT_TRUE(key.IsHasActualAuthenticationCapability());
-  ASSERT_TRUE(key.IsHasActualEncryptionCapability());
-  ASSERT_TRUE(key.IsHasActualSigningCapability());
+  ASSERT_TRUE(key.IsHasActualCertCap());
+  ASSERT_TRUE(key.IsHasActualAuthCap());
+  ASSERT_TRUE(key.IsHasActualEncrCap());
+  ASSERT_TRUE(key.IsHasActualSignCap());
 
   GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
       .DeleteKey(result.GetFingerprint());
 }
 
 TEST_F(GpgCoreTest, GenerateKeyRSA4096Test) {
-  auto keygen_info = SecureCreateSharedObject<GenKeyInfo>();
-  keygen_info->SetName("foo_1");
-  keygen_info->SetEmail("[email protected]");
-  keygen_info->SetComment("hello gpgfrontend");
-  keygen_info->SetAlgo("rsa");
-  keygen_info->SetKeyLength(4096);
-  keygen_info->SetNonExpired(false);
-  keygen_info->SetNonPassPhrase(true);
+  auto p_info = QSharedPointer<KeyGenerateInfo>::create();
+  p_info->SetName("foo_1");
+  p_info->SetEmail("[email protected]");
+  p_info->SetComment("hello gpgfrontend");
+
+  auto [found, algo] = KeyGenerateInfo::SearchPrimaryKeyAlgo("rsa4096");
+  ASSERT_TRUE(found);
+  ASSERT_EQ(algo.Id(), "rsa4096");
+  p_info->SetAlgo(algo);
+
+  p_info->SetNonExpired(false);
+  p_info->SetNonPassPhrase(true);
 
   auto expire_time =
       QDateTime::currentDateTime().addSecs(static_cast<qint64>(24 * 3600));
-  keygen_info->SetExpireTime(expire_time);
-  keygen_info->SetNonPassPhrase(false);
+  p_info->SetExpireTime(expire_time);
+  p_info->SetNonPassPhrase(false);
 
   auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
-                                .GenerateKeySync(keygen_info);
+                                .GenerateKeySync(p_info);
 
   ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
   ASSERT_EQ(data_object->GetObjectSize(), 1);
@@ -119,22 +146,26 @@ TEST_F(GpgCoreTest, GenerateKeyRSA4096Test) {
 }
 
 TEST_F(GpgCoreTest, GenerateKeyDSA2048Test) {
-  auto keygen_info = SecureCreateSharedObject<GenKeyInfo>();
-  keygen_info->SetName("foo_1");
-  keygen_info->SetEmail("[email protected]");
-  keygen_info->SetComment("hello gpgfrontend");
-  keygen_info->SetAlgo("dsa");
-  keygen_info->SetKeyLength(2048);
-  keygen_info->SetNonExpired(false);
-  keygen_info->SetNonPassPhrase(true);
+  auto p_info = QSharedPointer<KeyGenerateInfo>::create();
+  p_info->SetName("foo_1");
+  p_info->SetEmail("[email protected]");
+  p_info->SetComment("hello gpgfrontend");
+
+  auto [found, algo] = KeyGenerateInfo::SearchPrimaryKeyAlgo("dsa2048");
+  ASSERT_TRUE(found);
+  ASSERT_EQ(algo.Id(), "dsa2048");
+  p_info->SetAlgo(algo);
+
+  p_info->SetNonExpired(false);
+  p_info->SetNonPassPhrase(true);
 
   auto expire_time =
       QDateTime::currentDateTime().addSecs(static_cast<qint64>(24 * 3600));
-  keygen_info->SetExpireTime(expire_time);
-  keygen_info->SetNonPassPhrase(false);
+  p_info->SetExpireTime(expire_time);
+  p_info->SetNonPassPhrase(false);
 
   auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
-                                .GenerateKeySync(keygen_info);
+                                .GenerateKeySync(p_info);
   ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
   ASSERT_EQ(data_object->GetObjectSize(), 1);
   ASSERT_TRUE(data_object->Check<GpgGenerateKeyResult>());
@@ -154,36 +185,41 @@ TEST_F(GpgCoreTest, GenerateKeyDSA2048Test) {
   ASSERT_EQ(key.GetPrimaryKeyLength(), 2048);
   ASSERT_GT(key.GetExpireTime(), QDateTime::currentDateTime());
 
-  ASSERT_TRUE(key.IsHasCertificationCapability());
-  ASSERT_TRUE(key.IsHasAuthenticationCapability());
-  ASSERT_FALSE(key.IsHasEncryptionCapability());
-  ASSERT_TRUE(key.IsHasSigningCapability());
+  ASSERT_TRUE(key.IsHasCertCap());
+  ASSERT_TRUE(key.IsHasAuthCap());
+  ASSERT_FALSE(key.IsHasEncrCap());
+  ASSERT_TRUE(key.IsHasSignCap());
 
-  ASSERT_TRUE(key.IsHasActualCertificationCapability());
-  ASSERT_TRUE(key.IsHasActualAuthenticationCapability());
-  ASSERT_FALSE(key.IsHasActualEncryptionCapability());
-  ASSERT_TRUE(key.IsHasActualSigningCapability());
+  ASSERT_TRUE(key.IsHasActualCertCap());
+  ASSERT_TRUE(key.IsHasActualAuthCap());
+  ASSERT_FALSE(key.IsHasActualEncrCap());
+  ASSERT_TRUE(key.IsHasActualSignCap());
 
   GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
       .DeleteKey(result.GetFingerprint());
 }
 
 TEST_F(GpgCoreTest, GenerateKeyED25519Test) {
-  auto keygen_info = SecureCreateSharedObject<GenKeyInfo>();
-  keygen_info->SetName("foo_4");
-  keygen_info->SetEmail("[email protected]");
-  keygen_info->SetComment("hello gpgfrontend");
-  keygen_info->SetAlgo("ed25519");
-  keygen_info->SetNonExpired(false);
-  keygen_info->SetNonPassPhrase(true);
+  auto p_info = QSharedPointer<KeyGenerateInfo>::create();
+  p_info->SetName("foo_4");
+  p_info->SetEmail("[email protected]");
+  p_info->SetComment("hello gpgfrontend");
+
+  auto [found, algo] = KeyGenerateInfo::SearchPrimaryKeyAlgo("ed25519");
+  ASSERT_TRUE(found);
+  ASSERT_EQ(algo.Id(), "ed25519");
+  p_info->SetAlgo(algo);
+
+  p_info->SetNonExpired(false);
+  p_info->SetNonPassPhrase(true);
 
   auto expire_time =
       QDateTime::currentDateTime().addSecs(static_cast<qint64>(24 * 3600));
-  keygen_info->SetExpireTime(expire_time);
-  keygen_info->SetNonPassPhrase(false);
+  p_info->SetExpireTime(expire_time);
+  p_info->SetNonPassPhrase(false);
 
   auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
-                                .GenerateKeySync(keygen_info);
+                                .GenerateKeySync(p_info);
   ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
   ASSERT_EQ(data_object->GetObjectSize(), 1);
   ASSERT_TRUE(data_object->Check<GpgGenerateKeyResult>());
@@ -203,37 +239,46 @@ TEST_F(GpgCoreTest, GenerateKeyED25519Test) {
   ASSERT_EQ(key.GetPrimaryKeyLength(), 255);
   ASSERT_GT(key.GetExpireTime(), QDateTime::currentDateTime());
 
-  ASSERT_TRUE(key.IsHasCertificationCapability());
-  ASSERT_TRUE(key.IsHasAuthenticationCapability());
-  ASSERT_FALSE(key.IsHasEncryptionCapability());
-  ASSERT_TRUE(key.IsHasSigningCapability());
+  ASSERT_TRUE(key.IsHasCertCap());
+  ASSERT_TRUE(key.IsHasAuthCap());
+  ASSERT_FALSE(key.IsHasEncrCap());
+  ASSERT_TRUE(key.IsHasSignCap());
 
-  ASSERT_TRUE(key.IsHasActualCertificationCapability());
-  ASSERT_TRUE(key.IsHasActualAuthenticationCapability());
-  ASSERT_FALSE(key.IsHasActualEncryptionCapability());
-  ASSERT_TRUE(key.IsHasActualSigningCapability());
+  ASSERT_TRUE(key.IsHasActualCertCap());
+  ASSERT_TRUE(key.IsHasActualAuthCap());
+  ASSERT_FALSE(key.IsHasActualEncrCap());
+  ASSERT_TRUE(key.IsHasActualSignCap());
 
   GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
       .DeleteKey(result.GetFingerprint());
 }
 
 TEST_F(GpgCoreTest, GenerateKeyED25519CV25519Test) {
-  auto keygen_info = SecureCreateSharedObject<GenKeyInfo>();
-  keygen_info->SetName("foo_ec");
-  keygen_info->SetEmail("[email protected]");
-  keygen_info->SetComment("ecccc");
-  keygen_info->SetAlgo("ed25519");
-  keygen_info->SetNonExpired(true);
-  keygen_info->SetNonPassPhrase(true);
-
-  auto subkeygen_info = SecureCreateSharedObject<GenKeyInfo>(true);
-  subkeygen_info->SetAlgo("cv25519");
-  subkeygen_info->SetNonExpired(true);
-  subkeygen_info->SetNonPassPhrase(true);
-
-  auto [err, data_object] =
-      GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
-          .GenerateKeyWithSubkeySync(keygen_info, subkeygen_info);
+  auto p_info = QSharedPointer<KeyGenerateInfo>::create();
+  p_info->SetName("foo_ec");
+  p_info->SetEmail("[email protected]");
+  p_info->SetComment("ecccc");
+
+  auto [found, algo] = KeyGenerateInfo::SearchPrimaryKeyAlgo("ed25519");
+  ASSERT_TRUE(found);
+  ASSERT_EQ(algo.Id(), "ed25519");
+  p_info->SetAlgo(algo);
+
+  p_info->SetNonExpired(true);
+  p_info->SetNonPassPhrase(true);
+
+  auto s_info = QSharedPointer<KeyGenerateInfo>::create(true);
+
+  std::tie(found, algo) = KeyGenerateInfo::SearchSubKeyAlgo("cv25519");
+  ASSERT_TRUE(found);
+  ASSERT_EQ(algo.Id(), "cv25519");
+  s_info->SetAlgo(algo);
+
+  s_info->SetNonExpired(true);
+  s_info->SetNonPassPhrase(true);
+
+  auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
+                                .GenerateKeyWithSubkeySync(p_info, s_info);
 
   ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
   ASSERT_TRUE(
@@ -255,10 +300,10 @@ TEST_F(GpgCoreTest, GenerateKeyED25519CV25519Test) {
   ASSERT_EQ(key.GetPrimaryKeyLength(), 255);
   ASSERT_EQ(key.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_TRUE(key.IsHasCertificationCapability());
-  ASSERT_TRUE(key.IsHasAuthenticationCapability());
-  ASSERT_TRUE(key.IsHasEncryptionCapability());
-  ASSERT_TRUE(key.IsHasSigningCapability());
+  ASSERT_TRUE(key.IsHasCertCap());
+  ASSERT_TRUE(key.IsHasAuthCap());
+  ASSERT_TRUE(key.IsHasEncrCap());
+  ASSERT_TRUE(key.IsHasSignCap());
 
   ASSERT_FALSE(key.GetSubKeys()->empty());
   ASSERT_EQ(key.GetSubKeys()->size(), 2);
@@ -270,36 +315,45 @@ TEST_F(GpgCoreTest, GenerateKeyED25519CV25519Test) {
   ASSERT_EQ(subkey.GetKeyLength(), 255);
   ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertificationCapability());
-  ASSERT_FALSE(subkey.IsHasAuthenticationCapability());
-  ASSERT_TRUE(subkey.IsHasEncryptionCapability());
-  ASSERT_FALSE(subkey.IsHasSigningCapability());
+  ASSERT_FALSE(subkey.IsHasCertCap());
+  ASSERT_FALSE(subkey.IsHasAuthCap());
+  ASSERT_TRUE(subkey.IsHasEncrCap());
+  ASSERT_FALSE(subkey.IsHasSignCap());
 
-  ASSERT_TRUE(key.IsHasActualCertificationCapability());
-  ASSERT_TRUE(key.IsHasActualAuthenticationCapability());
-  ASSERT_TRUE(key.IsHasActualEncryptionCapability());
-  ASSERT_TRUE(key.IsHasActualSigningCapability());
+  ASSERT_TRUE(key.IsHasActualCertCap());
+  ASSERT_TRUE(key.IsHasActualAuthCap());
+  ASSERT_TRUE(key.IsHasActualEncrCap());
+  ASSERT_TRUE(key.IsHasActualSignCap());
 
   GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel).DeleteKey(fpr);
 }
 
 TEST_F(GpgCoreTest, GenerateKeyED25519NISTP256Test) {
-  auto keygen_info = SecureCreateSharedObject<GenKeyInfo>();
-  keygen_info->SetName("foo_ec2");
-  keygen_info->SetEmail("[email protected]");
-  keygen_info->SetComment("ecccc");
-  keygen_info->SetAlgo("ed25519");
-  keygen_info->SetNonExpired(true);
-  keygen_info->SetNonPassPhrase(true);
-
-  auto subkeygen_info = SecureCreateSharedObject<GenKeyInfo>(true);
-  subkeygen_info->SetAlgo("nistp256");
-  subkeygen_info->SetNonExpired(true);
-  subkeygen_info->SetNonPassPhrase(true);
-
-  auto [err, data_object] =
-      GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
-          .GenerateKeyWithSubkeySync(keygen_info, subkeygen_info);
+  auto p_info = QSharedPointer<KeyGenerateInfo>::create();
+  p_info->SetName("foo_ec2");
+  p_info->SetEmail("[email protected]");
+  p_info->SetComment("ecccc");
+
+  auto [found, algo] = KeyGenerateInfo::SearchPrimaryKeyAlgo("ed25519");
+  ASSERT_TRUE(found);
+  ASSERT_EQ(algo.Id(), "ed25519");
+  p_info->SetAlgo(algo);
+
+  p_info->SetNonExpired(true);
+  p_info->SetNonPassPhrase(true);
+
+  auto s_info = QSharedPointer<KeyGenerateInfo>::create(true);
+
+  std::tie(found, algo) = KeyGenerateInfo::SearchSubKeyAlgo("nistp256");
+  ASSERT_TRUE(found);
+  ASSERT_EQ(algo.Id(), "nistp256");
+  s_info->SetAlgo(algo);
+
+  s_info->SetNonExpired(true);
+  s_info->SetNonPassPhrase(true);
+
+  auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
+                                .GenerateKeyWithSubkeySync(p_info, s_info);
 
   ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
   ASSERT_TRUE(
@@ -321,10 +375,10 @@ TEST_F(GpgCoreTest, GenerateKeyED25519NISTP256Test) {
   ASSERT_EQ(key.GetPrimaryKeyLength(), 255);
   ASSERT_EQ(key.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_TRUE(key.IsHasCertificationCapability());
-  ASSERT_TRUE(key.IsHasAuthenticationCapability());
-  ASSERT_TRUE(key.IsHasEncryptionCapability());
-  ASSERT_TRUE(key.IsHasSigningCapability());
+  ASSERT_TRUE(key.IsHasCertCap());
+  ASSERT_TRUE(key.IsHasAuthCap());
+  ASSERT_TRUE(key.IsHasEncrCap());
+  ASSERT_TRUE(key.IsHasSignCap());
 
   ASSERT_FALSE(key.GetSubKeys()->empty());
   ASSERT_EQ(key.GetSubKeys()->size(), 2);
@@ -336,36 +390,45 @@ TEST_F(GpgCoreTest, GenerateKeyED25519NISTP256Test) {
   ASSERT_EQ(subkey.GetKeyLength(), 256);
   ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertificationCapability());
-  ASSERT_FALSE(subkey.IsHasAuthenticationCapability());
-  ASSERT_TRUE(subkey.IsHasEncryptionCapability());
-  ASSERT_FALSE(subkey.IsHasSigningCapability());
+  ASSERT_FALSE(subkey.IsHasCertCap());
+  ASSERT_FALSE(subkey.IsHasAuthCap());
+  ASSERT_TRUE(subkey.IsHasEncrCap());
+  ASSERT_FALSE(subkey.IsHasSignCap());
 
-  ASSERT_TRUE(key.IsHasActualCertificationCapability());
-  ASSERT_TRUE(key.IsHasActualAuthenticationCapability());
-  ASSERT_TRUE(key.IsHasActualEncryptionCapability());
-  ASSERT_TRUE(key.IsHasActualSigningCapability());
+  ASSERT_TRUE(key.IsHasActualCertCap());
+  ASSERT_TRUE(key.IsHasActualAuthCap());
+  ASSERT_TRUE(key.IsHasActualEncrCap());
+  ASSERT_TRUE(key.IsHasActualSignCap());
 
   GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel).DeleteKey(fpr);
 }
 
 TEST_F(GpgCoreTest, GenerateKeyED25519BRAINPOOLP256R1Test) {
-  auto keygen_info = SecureCreateSharedObject<GenKeyInfo>();
-  keygen_info->SetName("foo_ec3");
-  keygen_info->SetEmail("[email protected]");
-  keygen_info->SetComment("ecccc3");
-  keygen_info->SetAlgo("ed25519");
-  keygen_info->SetNonExpired(true);
-  keygen_info->SetNonPassPhrase(true);
-
-  auto subkeygen_info = SecureCreateSharedObject<GenKeyInfo>(true);
-  subkeygen_info->SetAlgo("brainpoolp256r1");
-  subkeygen_info->SetNonExpired(true);
-  subkeygen_info->SetNonPassPhrase(true);
-
-  auto [err, data_object] =
-      GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
-          .GenerateKeyWithSubkeySync(keygen_info, subkeygen_info);
+  auto p_info = QSharedPointer<KeyGenerateInfo>::create();
+  p_info->SetName("foo_ec3");
+  p_info->SetEmail("[email protected]");
+  p_info->SetComment("ecccc3");
+
+  auto [found, algo] = KeyGenerateInfo::SearchPrimaryKeyAlgo("ed25519");
+  ASSERT_TRUE(found);
+  ASSERT_EQ(algo.Id(), "ed25519");
+  p_info->SetAlgo(algo);
+
+  p_info->SetNonExpired(true);
+  p_info->SetNonPassPhrase(true);
+
+  auto s_info = QSharedPointer<KeyGenerateInfo>::create(true);
+
+  std::tie(found, algo) = KeyGenerateInfo::SearchSubKeyAlgo("brainpoolp256r1");
+  ASSERT_TRUE(found);
+  ASSERT_EQ(algo.Id(), "brainpoolp256r1");
+  s_info->SetAlgo(algo);
+
+  s_info->SetNonExpired(true);
+  s_info->SetNonPassPhrase(true);
+
+  auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
+                                .GenerateKeyWithSubkeySync(p_info, s_info);
 
   ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
   ASSERT_TRUE(
@@ -387,10 +450,10 @@ TEST_F(GpgCoreTest, GenerateKeyED25519BRAINPOOLP256R1Test) {
   ASSERT_EQ(key.GetPrimaryKeyLength(), 255);
   ASSERT_EQ(key.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_TRUE(key.IsHasCertificationCapability());
-  ASSERT_TRUE(key.IsHasAuthenticationCapability());
-  ASSERT_TRUE(key.IsHasEncryptionCapability());
-  ASSERT_TRUE(key.IsHasSigningCapability());
+  ASSERT_TRUE(key.IsHasCertCap());
+  ASSERT_TRUE(key.IsHasAuthCap());
+  ASSERT_TRUE(key.IsHasEncrCap());
+  ASSERT_TRUE(key.IsHasSignCap());
 
   ASSERT_FALSE(key.GetSubKeys()->empty());
   ASSERT_EQ(key.GetSubKeys()->size(), 2);
@@ -402,35 +465,40 @@ TEST_F(GpgCoreTest, GenerateKeyED25519BRAINPOOLP256R1Test) {
   ASSERT_EQ(subkey.GetKeyLength(), 256);
   ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertificationCapability());
-  ASSERT_FALSE(subkey.IsHasAuthenticationCapability());
-  ASSERT_TRUE(subkey.IsHasEncryptionCapability());
-  ASSERT_FALSE(subkey.IsHasSigningCapability());
+  ASSERT_FALSE(subkey.IsHasCertCap());
+  ASSERT_FALSE(subkey.IsHasAuthCap());
+  ASSERT_TRUE(subkey.IsHasEncrCap());
+  ASSERT_FALSE(subkey.IsHasSignCap());
 
-  ASSERT_TRUE(key.IsHasActualCertificationCapability());
-  ASSERT_TRUE(key.IsHasActualAuthenticationCapability());
-  ASSERT_TRUE(key.IsHasActualEncryptionCapability());
-  ASSERT_TRUE(key.IsHasActualSigningCapability());
+  ASSERT_TRUE(key.IsHasActualCertCap());
+  ASSERT_TRUE(key.IsHasActualAuthCap());
+  ASSERT_TRUE(key.IsHasActualEncrCap());
+  ASSERT_TRUE(key.IsHasActualSignCap());
 
   GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel).DeleteKey(fpr);
 }
 
 TEST_F(GpgCoreTest, GenerateKeyNISTP256Test) {
-  auto keygen_info = SecureCreateSharedObject<GenKeyInfo>();
-  keygen_info->SetName("foo_4");
-  keygen_info->SetEmail("[email protected]");
-  keygen_info->SetComment("hello gpgfrontend");
-  keygen_info->SetAlgo("nistp256");
-  keygen_info->SetNonExpired(false);
-  keygen_info->SetNonPassPhrase(true);
+  auto p_info = QSharedPointer<KeyGenerateInfo>::create();
+  p_info->SetName("foo_4");
+  p_info->SetEmail("[email protected]");
+  p_info->SetComment("hello gpgfrontend");
+
+  auto [found, algo] = KeyGenerateInfo::SearchPrimaryKeyAlgo("nistp256");
+  ASSERT_TRUE(found);
+  ASSERT_EQ(algo.Id(), "nistp256");
+  p_info->SetAlgo(algo);
+
+  p_info->SetNonExpired(false);
+  p_info->SetNonPassPhrase(true);
 
   auto expire_time =
       QDateTime::currentDateTime().addSecs(static_cast<qint64>(24 * 3600));
-  keygen_info->SetExpireTime(expire_time);
-  keygen_info->SetNonPassPhrase(false);
+  p_info->SetExpireTime(expire_time);
+  p_info->SetNonPassPhrase(false);
 
   auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
-                                .GenerateKeySync(keygen_info);
+                                .GenerateKeySync(p_info);
   ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
   ASSERT_EQ(data_object->GetObjectSize(), 1);
   ASSERT_TRUE(data_object->Check<GpgGenerateKeyResult>());
@@ -451,36 +519,41 @@ TEST_F(GpgCoreTest, GenerateKeyNISTP256Test) {
   ASSERT_EQ(key.GetPrimaryKeyLength(), 256);
   ASSERT_GT(key.GetExpireTime(), QDateTime::currentDateTime());
 
-  ASSERT_TRUE(key.IsHasCertificationCapability());
-  ASSERT_TRUE(key.IsHasAuthenticationCapability());
-  ASSERT_FALSE(key.IsHasEncryptionCapability());
-  ASSERT_TRUE(key.IsHasSigningCapability());
+  ASSERT_TRUE(key.IsHasCertCap());
+  ASSERT_TRUE(key.IsHasAuthCap());
+  ASSERT_FALSE(key.IsHasEncrCap());
+  ASSERT_TRUE(key.IsHasSignCap());
 
-  ASSERT_TRUE(key.IsHasActualCertificationCapability());
-  ASSERT_TRUE(key.IsHasActualAuthenticationCapability());
-  ASSERT_FALSE(key.IsHasActualEncryptionCapability());
-  ASSERT_TRUE(key.IsHasActualSigningCapability());
+  ASSERT_TRUE(key.IsHasActualCertCap());
+  ASSERT_TRUE(key.IsHasActualAuthCap());
+  ASSERT_FALSE(key.IsHasActualEncrCap());
+  ASSERT_TRUE(key.IsHasActualSignCap());
 
   GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
       .DeleteKey(result.GetFingerprint());
 }
 
 TEST_F(GpgCoreTest, GenerateKeyED448Test) {
-  auto keygen_info = SecureCreateSharedObject<GenKeyInfo>();
-  keygen_info->SetName("foo_4");
-  keygen_info->SetEmail("[email protected]");
-  keygen_info->SetComment("hello gpgfrontend");
-  keygen_info->SetAlgo("ed448");
-  keygen_info->SetNonExpired(false);
-  keygen_info->SetNonPassPhrase(true);
+  auto p_info = QSharedPointer<KeyGenerateInfo>::create();
+  p_info->SetName("foo_4");
+  p_info->SetEmail("[email protected]");
+  p_info->SetComment("hello gpgfrontend");
+
+  auto [found, algo] = KeyGenerateInfo::SearchPrimaryKeyAlgo("ed448");
+  ASSERT_TRUE(found);
+  ASSERT_EQ(algo.Id(), "ed448");
+  p_info->SetAlgo(algo);
+
+  p_info->SetNonExpired(false);
+  p_info->SetNonPassPhrase(true);
 
   auto expire_time =
       QDateTime::currentDateTime().addSecs(static_cast<qint64>(24 * 3600));
-  keygen_info->SetExpireTime(expire_time);
-  keygen_info->SetNonPassPhrase(false);
+  p_info->SetExpireTime(expire_time);
+  p_info->SetNonPassPhrase(false);
 
   auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
-                                .GenerateKeySync(keygen_info);
+                                .GenerateKeySync(p_info);
   ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
   ASSERT_EQ(data_object->GetObjectSize(), 1);
   ASSERT_TRUE(data_object->Check<GpgGenerateKeyResult>());
@@ -501,36 +574,41 @@ TEST_F(GpgCoreTest, GenerateKeyED448Test) {
   ASSERT_EQ(key.GetPrimaryKeyLength(), 448);
   ASSERT_GT(key.GetExpireTime(), QDateTime::currentDateTime());
 
-  ASSERT_TRUE(key.IsHasCertificationCapability());
-  ASSERT_TRUE(key.IsHasAuthenticationCapability());
-  ASSERT_FALSE(key.IsHasEncryptionCapability());
-  ASSERT_TRUE(key.IsHasSigningCapability());
+  ASSERT_TRUE(key.IsHasCertCap());
+  ASSERT_TRUE(key.IsHasAuthCap());
+  ASSERT_FALSE(key.IsHasEncrCap());
+  ASSERT_TRUE(key.IsHasSignCap());
 
-  ASSERT_TRUE(key.IsHasActualCertificationCapability());
-  ASSERT_TRUE(key.IsHasActualAuthenticationCapability());
-  ASSERT_FALSE(key.IsHasActualEncryptionCapability());
-  ASSERT_TRUE(key.IsHasActualSigningCapability());
+  ASSERT_TRUE(key.IsHasActualCertCap());
+  ASSERT_TRUE(key.IsHasActualAuthCap());
+  ASSERT_FALSE(key.IsHasActualEncrCap());
+  ASSERT_TRUE(key.IsHasActualSignCap());
 
   GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
       .DeleteKey(result.GetFingerprint());
 }
 
 TEST_F(GpgCoreTest, GenerateKeySECP256K1Test) {
-  auto keygen_info = SecureCreateSharedObject<GenKeyInfo>();
-  keygen_info->SetName("foo_4");
-  keygen_info->SetEmail("[email protected]");
-  keygen_info->SetComment("hello gpgfrontend");
-  keygen_info->SetAlgo("secp256k1");
-  keygen_info->SetNonExpired(false);
-  keygen_info->SetNonPassPhrase(true);
+  auto p_info = QSharedPointer<KeyGenerateInfo>::create();
+  p_info->SetName("foo_4");
+  p_info->SetEmail("[email protected]");
+  p_info->SetComment("hello gpgfrontend");
+
+  auto [found, algo] = KeyGenerateInfo::SearchPrimaryKeyAlgo("secp256k1");
+  ASSERT_TRUE(found);
+  ASSERT_EQ(algo.Id(), "secp256k1");
+  p_info->SetAlgo(algo);
+
+  p_info->SetNonExpired(false);
+  p_info->SetNonPassPhrase(true);
 
   auto expire_time =
       QDateTime::currentDateTime().addSecs(static_cast<qint64>(24 * 3600));
-  keygen_info->SetExpireTime(expire_time);
-  keygen_info->SetNonPassPhrase(false);
+  p_info->SetExpireTime(expire_time);
+  p_info->SetNonPassPhrase(false);
 
   auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
-                                .GenerateKeySync(keygen_info);
+                                .GenerateKeySync(p_info);
   ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
   ASSERT_EQ(data_object->GetObjectSize(), 1);
   ASSERT_TRUE(data_object->Check<GpgGenerateKeyResult>());
@@ -551,15 +629,15 @@ TEST_F(GpgCoreTest, GenerateKeySECP256K1Test) {
   ASSERT_EQ(key.GetPrimaryKeyLength(), 256);
   ASSERT_GT(key.GetExpireTime(), QDateTime::currentDateTime());
 
-  ASSERT_TRUE(key.IsHasCertificationCapability());
-  ASSERT_TRUE(key.IsHasAuthenticationCapability());
-  ASSERT_FALSE(key.IsHasEncryptionCapability());
-  ASSERT_TRUE(key.IsHasSigningCapability());
+  ASSERT_TRUE(key.IsHasCertCap());
+  ASSERT_TRUE(key.IsHasAuthCap());
+  ASSERT_FALSE(key.IsHasEncrCap());
+  ASSERT_TRUE(key.IsHasSignCap());
 
-  ASSERT_TRUE(key.IsHasActualCertificationCapability());
-  ASSERT_TRUE(key.IsHasActualAuthenticationCapability());
-  ASSERT_FALSE(key.IsHasActualEncryptionCapability());
-  ASSERT_TRUE(key.IsHasActualSigningCapability());
+  ASSERT_TRUE(key.IsHasActualCertCap());
+  ASSERT_TRUE(key.IsHasActualAuthCap());
+  ASSERT_FALSE(key.IsHasActualEncrCap());
+  ASSERT_TRUE(key.IsHasActualSignCap());
 
   GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
       .DeleteKey(result.GetFingerprint());
diff --git a/src/test/core/GpgCoreTestSubkeygen.cpp b/src/test/core/GpgCoreTestSubkeygen.cpp
index c4fe92b0..bbaa2be0 100644
--- a/src/test/core/GpgCoreTestSubkeygen.cpp
+++ b/src/test/core/GpgCoreTestSubkeygen.cpp
@@ -29,27 +29,31 @@
 #include "GpgCoreTest.h"
 #include "core/function/gpg/GpgKeyGetter.h"
 #include "core/function/gpg/GpgKeyOpera.h"
-#include "core/model/GpgGenKeyInfo.h"
 #include "core/model/GpgGenerateKeyResult.h"
 #include "core/model/GpgKey.h"
+#include "core/model/GpgKeyGenerateInfo.h"
 #include "core/utils/GpgUtils.h"
 #include "core/utils/MemoryUtils.h"
 
 namespace GpgFrontend::Test {
 
 TEST_F(GpgCoreTest, GenerateSubkeyRSA2048Test) {
-  auto main_key = GpgKeyGetter::GetInstance().GetKey(
+  auto p_key = GpgKeyGetter::GetInstance().GetKey(
       "E87C6A2D8D95C818DE93B3AE6A2764F8298DEB29");
-  ASSERT_TRUE(main_key.IsGood());
+  ASSERT_TRUE(p_key.IsGood());
 
-  auto subkeygen_info = SecureCreateSharedObject<GenKeyInfo>(true);
-  subkeygen_info->SetAlgo("rsa");
-  subkeygen_info->SetKeyLength(2048);
-  subkeygen_info->SetNonExpired(true);
-  subkeygen_info->SetNonPassPhrase(true);
+  auto s_info = QSharedPointer<KeyGenerateInfo>::create(true);
+
+  auto [found, algo] = KeyGenerateInfo::SearchSubKeyAlgo("rsa2048");
+  ASSERT_TRUE(found);
+  ASSERT_EQ(algo.Id(), "rsa2048");
+  s_info->SetAlgo(algo);
+
+  s_info->SetNonExpired(true);
+  s_info->SetNonPassPhrase(true);
 
   auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
-                                .GenerateSubkeySync(main_key, subkeygen_info);
+                                .GenerateSubkeySync(p_key, s_info);
 
   ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
   ASSERT_EQ(data_object->GetObjectSize(), 1);
@@ -70,25 +74,29 @@ TEST_F(GpgCoreTest, GenerateSubkeyRSA2048Test) {
   ASSERT_EQ(subkey.GetKeyLength(), 2048);
   ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertificationCapability());
-  ASSERT_TRUE(subkey.IsHasAuthenticationCapability());
-  ASSERT_TRUE(subkey.IsHasEncryptionCapability());
-  ASSERT_TRUE(subkey.IsHasSigningCapability());
+  ASSERT_FALSE(subkey.IsHasCertCap());
+  ASSERT_TRUE(subkey.IsHasAuthCap());
+  ASSERT_TRUE(subkey.IsHasEncrCap());
+  ASSERT_TRUE(subkey.IsHasSignCap());
 }
 
 TEST_F(GpgCoreTest, GenerateSubkeyDSA2048Test) {
-  auto main_key = GpgKeyGetter::GetInstance().GetKey(
+  auto p_key = GpgKeyGetter::GetInstance().GetKey(
       "E87C6A2D8D95C818DE93B3AE6A2764F8298DEB29");
-  ASSERT_TRUE(main_key.IsGood());
+  ASSERT_TRUE(p_key.IsGood());
+
+  auto s_info = QSharedPointer<KeyGenerateInfo>::create(true);
 
-  auto subkeygen_info = SecureCreateSharedObject<GenKeyInfo>(true);
-  subkeygen_info->SetAlgo("dsa");
-  subkeygen_info->SetKeyLength(2048);
-  subkeygen_info->SetNonExpired(true);
-  subkeygen_info->SetNonPassPhrase(true);
+  auto [found, algo] = KeyGenerateInfo::SearchSubKeyAlgo("dsa2048");
+  ASSERT_TRUE(found);
+  ASSERT_EQ(algo.Id(), "dsa2048");
+  s_info->SetAlgo(algo);
+
+  s_info->SetNonExpired(true);
+  s_info->SetNonPassPhrase(true);
 
   auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
-                                .GenerateSubkeySync(main_key, subkeygen_info);
+                                .GenerateSubkeySync(p_key, s_info);
 
   ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
   ASSERT_EQ(data_object->GetObjectSize(), 1);
@@ -109,25 +117,29 @@ TEST_F(GpgCoreTest, GenerateSubkeyDSA2048Test) {
   ASSERT_EQ(subkey.GetKeyLength(), 2048);
   ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertificationCapability());
-  ASSERT_TRUE(subkey.IsHasAuthenticationCapability());
-  ASSERT_FALSE(subkey.IsHasEncryptionCapability());
-  ASSERT_TRUE(subkey.IsHasSigningCapability());
+  ASSERT_FALSE(subkey.IsHasCertCap());
+  ASSERT_TRUE(subkey.IsHasAuthCap());
+  ASSERT_FALSE(subkey.IsHasEncrCap());
+  ASSERT_TRUE(subkey.IsHasSignCap());
 }
 
 TEST_F(GpgCoreTest, GenerateSubkeyELG2048Test) {
-  auto main_key = GpgKeyGetter::GetInstance().GetKey(
+  auto p_key = GpgKeyGetter::GetInstance().GetKey(
       "E87C6A2D8D95C818DE93B3AE6A2764F8298DEB29");
-  ASSERT_TRUE(main_key.IsGood());
+  ASSERT_TRUE(p_key.IsGood());
+
+  auto s_info = QSharedPointer<KeyGenerateInfo>::create(true);
 
-  auto subkeygen_info = SecureCreateSharedObject<GenKeyInfo>(true);
-  subkeygen_info->SetAlgo("elg");
-  subkeygen_info->SetKeyLength(2048);
-  subkeygen_info->SetNonExpired(true);
-  subkeygen_info->SetNonPassPhrase(true);
+  auto [found, algo] = KeyGenerateInfo::SearchSubKeyAlgo("elg2048");
+  ASSERT_TRUE(found);
+  ASSERT_EQ(algo.Id(), "elg2048");
+  s_info->SetAlgo(algo);
+
+  s_info->SetNonExpired(true);
+  s_info->SetNonPassPhrase(true);
 
   auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
-                                .GenerateSubkeySync(main_key, subkeygen_info);
+                                .GenerateSubkeySync(p_key, s_info);
 
   ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
   ASSERT_EQ(data_object->GetObjectSize(), 1);
@@ -148,24 +160,29 @@ TEST_F(GpgCoreTest, GenerateSubkeyELG2048Test) {
   ASSERT_EQ(subkey.GetKeyLength(), 2048);
   ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertificationCapability());
-  ASSERT_FALSE(subkey.IsHasAuthenticationCapability());
-  ASSERT_TRUE(subkey.IsHasEncryptionCapability());
-  ASSERT_FALSE(subkey.IsHasSigningCapability());
+  ASSERT_FALSE(subkey.IsHasCertCap());
+  ASSERT_FALSE(subkey.IsHasAuthCap());
+  ASSERT_TRUE(subkey.IsHasEncrCap());
+  ASSERT_FALSE(subkey.IsHasSignCap());
 }
 
 TEST_F(GpgCoreTest, GenerateSubkeyED25519Test) {
-  auto main_key = GpgKeyGetter::GetInstance().GetKey(
+  auto p_key = GpgKeyGetter::GetInstance().GetKey(
       "E87C6A2D8D95C818DE93B3AE6A2764F8298DEB29");
-  ASSERT_TRUE(main_key.IsGood());
+  ASSERT_TRUE(p_key.IsGood());
+
+  auto s_info = QSharedPointer<KeyGenerateInfo>::create(true);
 
-  auto subkeygen_info = SecureCreateSharedObject<GenKeyInfo>(true);
-  subkeygen_info->SetAlgo("ed25519");
-  subkeygen_info->SetNonExpired(true);
-  subkeygen_info->SetNonPassPhrase(true);
+  auto [found, algo] = KeyGenerateInfo::SearchSubKeyAlgo("ed25519");
+  ASSERT_TRUE(found);
+  ASSERT_EQ(algo.Id(), "ed25519");
+  s_info->SetAlgo(algo);
+
+  s_info->SetNonExpired(true);
+  s_info->SetNonPassPhrase(true);
 
   auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
-                                .GenerateSubkeySync(main_key, subkeygen_info);
+                                .GenerateSubkeySync(p_key, s_info);
 
   ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
   ASSERT_EQ(data_object->GetObjectSize(), 1);
@@ -186,24 +203,29 @@ TEST_F(GpgCoreTest, GenerateSubkeyED25519Test) {
   ASSERT_EQ(subkey.GetKeyLength(), 255);
   ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertificationCapability());
-  ASSERT_TRUE(subkey.IsHasAuthenticationCapability());
-  ASSERT_FALSE(subkey.IsHasEncryptionCapability());
-  ASSERT_TRUE(subkey.IsHasSigningCapability());
+  ASSERT_FALSE(subkey.IsHasCertCap());
+  ASSERT_TRUE(subkey.IsHasAuthCap());
+  ASSERT_FALSE(subkey.IsHasEncrCap());
+  ASSERT_TRUE(subkey.IsHasSignCap());
 }
 
 TEST_F(GpgCoreTest, GenerateSubkeyCV25519Test) {
-  auto main_key = GpgKeyGetter::GetInstance().GetKey(
+  auto p_key = GpgKeyGetter::GetInstance().GetKey(
       "E87C6A2D8D95C818DE93B3AE6A2764F8298DEB29");
-  ASSERT_TRUE(main_key.IsGood());
+  ASSERT_TRUE(p_key.IsGood());
+
+  auto s_info = QSharedPointer<KeyGenerateInfo>::create(true);
 
-  auto subkeygen_info = SecureCreateSharedObject<GenKeyInfo>(true);
-  subkeygen_info->SetAlgo("cv25519");
-  subkeygen_info->SetNonExpired(true);
-  subkeygen_info->SetNonPassPhrase(true);
+  auto [found, algo] = KeyGenerateInfo::SearchSubKeyAlgo("cv25519");
+  ASSERT_TRUE(found);
+  ASSERT_EQ(algo.Id(), "cv25519");
+  s_info->SetAlgo(algo);
+
+  s_info->SetNonExpired(true);
+  s_info->SetNonPassPhrase(true);
 
   auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
-                                .GenerateSubkeySync(main_key, subkeygen_info);
+                                .GenerateSubkeySync(p_key, s_info);
 
   ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
   ASSERT_EQ(data_object->GetObjectSize(), 1);
@@ -224,23 +246,28 @@ TEST_F(GpgCoreTest, GenerateSubkeyCV25519Test) {
   ASSERT_EQ(subkey.GetKeyLength(), 255);
   ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertificationCapability());
-  ASSERT_FALSE(subkey.IsHasAuthenticationCapability());
-  ASSERT_TRUE(subkey.IsHasEncryptionCapability());
-  ASSERT_FALSE(subkey.IsHasSigningCapability());
+  ASSERT_FALSE(subkey.IsHasCertCap());
+  ASSERT_FALSE(subkey.IsHasAuthCap());
+  ASSERT_TRUE(subkey.IsHasEncrCap());
+  ASSERT_FALSE(subkey.IsHasSignCap());
 }
 
 TEST_F(GpgCoreTest, GenerateSubkeyNISTP256Test) {
-  auto main_key = GpgKeyGetter::GetInstance().GetKey(
+  auto p_key = GpgKeyGetter::GetInstance().GetKey(
       "E87C6A2D8D95C818DE93B3AE6A2764F8298DEB29");
-  ASSERT_TRUE(main_key.IsGood());
+  ASSERT_TRUE(p_key.IsGood());
+
+  auto s_info = QSharedPointer<KeyGenerateInfo>::create(true);
+
+  auto [found, algo] = KeyGenerateInfo::SearchSubKeyAlgo("nistp256");
+  ASSERT_TRUE(found);
+  ASSERT_EQ(algo.Id(), "nistp256");
+  s_info->SetAlgo(algo);
 
-  auto subkeygen_info = SecureCreateSharedObject<GenKeyInfo>(true);
-  subkeygen_info->SetAlgo("nistp256");
-  subkeygen_info->SetNonExpired(true);
+  s_info->SetNonExpired(true);
 
   auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
-                                .GenerateSubkeySync(main_key, subkeygen_info);
+                                .GenerateSubkeySync(p_key, s_info);
 
   ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
   ASSERT_EQ(data_object->GetObjectSize(), 1);
@@ -261,23 +288,28 @@ TEST_F(GpgCoreTest, GenerateSubkeyNISTP256Test) {
   ASSERT_EQ(subkey.GetKeyLength(), 256);
   ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertificationCapability());
-  ASSERT_FALSE(subkey.IsHasAuthenticationCapability());
-  ASSERT_TRUE(subkey.IsHasEncryptionCapability());
-  ASSERT_FALSE(subkey.IsHasSigningCapability());
+  ASSERT_FALSE(subkey.IsHasCertCap());
+  ASSERT_FALSE(subkey.IsHasAuthCap());
+  ASSERT_TRUE(subkey.IsHasEncrCap());
+  ASSERT_FALSE(subkey.IsHasSignCap());
 }
 
 TEST_F(GpgCoreTest, GenerateSubkeyBRAINPOOLP256R1Test) {
-  auto main_key = GpgKeyGetter::GetInstance().GetKey(
+  auto p_key = GpgKeyGetter::GetInstance().GetKey(
       "E87C6A2D8D95C818DE93B3AE6A2764F8298DEB29");
-  ASSERT_TRUE(main_key.IsGood());
+  ASSERT_TRUE(p_key.IsGood());
+
+  auto s_info = QSharedPointer<KeyGenerateInfo>::create(true);
+
+  auto [found, algo] = KeyGenerateInfo::SearchSubKeyAlgo("brainpoolp256r1");
+  ASSERT_TRUE(found);
+  ASSERT_EQ(algo.Id(), "brainpoolp256r1");
+  s_info->SetAlgo(algo);
 
-  auto subkeygen_info = SecureCreateSharedObject<GenKeyInfo>(true);
-  subkeygen_info->SetAlgo("brainpoolp256r1");
-  subkeygen_info->SetNonExpired(true);
+  s_info->SetNonExpired(true);
 
   auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
-                                .GenerateSubkeySync(main_key, subkeygen_info);
+                                .GenerateSubkeySync(p_key, s_info);
 
   ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
   ASSERT_EQ(data_object->GetObjectSize(), 1);
@@ -298,23 +330,28 @@ TEST_F(GpgCoreTest, GenerateSubkeyBRAINPOOLP256R1Test) {
   ASSERT_EQ(subkey.GetKeyLength(), 256);
   ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertificationCapability());
-  ASSERT_FALSE(subkey.IsHasAuthenticationCapability());
-  ASSERT_TRUE(subkey.IsHasEncryptionCapability());
-  ASSERT_FALSE(subkey.IsHasSigningCapability());
+  ASSERT_FALSE(subkey.IsHasCertCap());
+  ASSERT_FALSE(subkey.IsHasAuthCap());
+  ASSERT_TRUE(subkey.IsHasEncrCap());
+  ASSERT_FALSE(subkey.IsHasSignCap());
 }
 
 TEST_F(GpgCoreTest, GenerateSubkeyX448Test) {
-  auto main_key = GpgKeyGetter::GetInstance().GetKey(
+  auto p_key = GpgKeyGetter::GetInstance().GetKey(
       "E87C6A2D8D95C818DE93B3AE6A2764F8298DEB29");
-  ASSERT_TRUE(main_key.IsGood());
+  ASSERT_TRUE(p_key.IsGood());
 
-  auto subkeygen_info = SecureCreateSharedObject<GenKeyInfo>(true);
-  subkeygen_info->SetAlgo("x448");
-  subkeygen_info->SetNonExpired(true);
+  auto s_info = QSharedPointer<KeyGenerateInfo>::create(true);
+
+  auto [found, algo] = KeyGenerateInfo::SearchSubKeyAlgo("x448");
+  ASSERT_TRUE(found);
+  ASSERT_EQ(algo.Id(), "x448");
+  s_info->SetAlgo(algo);
+
+  s_info->SetNonExpired(true);
 
   auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
-                                .GenerateSubkeySync(main_key, subkeygen_info);
+                                .GenerateSubkeySync(p_key, s_info);
 
   ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
   ASSERT_EQ(data_object->GetObjectSize(), 1);
@@ -335,23 +372,28 @@ TEST_F(GpgCoreTest, GenerateSubkeyX448Test) {
   ASSERT_EQ(subkey.GetKeyLength(), 448);
   ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertificationCapability());
-  ASSERT_FALSE(subkey.IsHasAuthenticationCapability());
-  ASSERT_TRUE(subkey.IsHasEncryptionCapability());
-  ASSERT_FALSE(subkey.IsHasSigningCapability());
+  ASSERT_FALSE(subkey.IsHasCertCap());
+  ASSERT_FALSE(subkey.IsHasAuthCap());
+  ASSERT_TRUE(subkey.IsHasEncrCap());
+  ASSERT_FALSE(subkey.IsHasSignCap());
 }
 
 TEST_F(GpgCoreTest, GenerateSubkeySECP256K1Test) {
-  auto main_key = GpgKeyGetter::GetInstance().GetKey(
+  auto p_key = GpgKeyGetter::GetInstance().GetKey(
       "E87C6A2D8D95C818DE93B3AE6A2764F8298DEB29");
-  ASSERT_TRUE(main_key.IsGood());
+  ASSERT_TRUE(p_key.IsGood());
+
+  auto s_info = QSharedPointer<KeyGenerateInfo>::create(true);
+
+  auto [found, algo] = KeyGenerateInfo::SearchSubKeyAlgo("secp256k1");
+  ASSERT_TRUE(found);
+  ASSERT_EQ(algo.Id(), "secp256k1");
+  s_info->SetAlgo(algo);
 
-  auto subkeygen_info = SecureCreateSharedObject<GenKeyInfo>(true);
-  subkeygen_info->SetAlgo("secp256k1");
-  subkeygen_info->SetNonExpired(true);
+  s_info->SetNonExpired(true);
 
   auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
-                                .GenerateSubkeySync(main_key, subkeygen_info);
+                                .GenerateSubkeySync(p_key, s_info);
 
   ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
   ASSERT_EQ(data_object->GetObjectSize(), 1);
@@ -372,10 +414,10 @@ TEST_F(GpgCoreTest, GenerateSubkeySECP256K1Test) {
   ASSERT_EQ(subkey.GetKeyLength(), 256);
   ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertificationCapability());
-  ASSERT_FALSE(subkey.IsHasAuthenticationCapability());
-  ASSERT_TRUE(subkey.IsHasEncryptionCapability());
-  ASSERT_FALSE(subkey.IsHasSigningCapability());
+  ASSERT_FALSE(subkey.IsHasCertCap());
+  ASSERT_FALSE(subkey.IsHasAuthCap());
+  ASSERT_TRUE(subkey.IsHasEncrCap());
+  ASSERT_FALSE(subkey.IsHasSignCap());
 }
 
 }  // namespace GpgFrontend::Test
\ No newline at end of file