Enhance code robustness;

Improve performance for GpgKey;
Fix code defects. Makes the update response to changes in the key database directed.

Signed-off-by: Saturneric <[email protected]>

18 files changed, 455 insertions, 177 deletions

diff --git a/include/gpg/GpgContext.h b/include/gpg/GpgContext.h
index 81ff3152..e8ae9feb 100644
--- a/include/gpg/GpgContext.h
+++ b/include/gpg/GpgContext.h
@@ -31,7 +31,7 @@
 #include "GpgGenKeyInfo.h"
 #include "GpgKey.h"
 
-typedef QLinkedList<GpgKey> GpgKeyList;
+using GpgKeyList = QLinkedList<GpgKey>;
 
 class GpgImportedKey {
 public:
@@ -82,15 +82,17 @@ namespace GpgME {
 
     public:
         GpgContext(); // Constructor
+
         ~GpgContext() override; // Destructor
+
         GpgImportInformation importKey(QByteArray inBuffer);
 
+        const GpgKeyList &getKeys() const;
+
         bool exportKeys(QStringList *uidList, QByteArray *outBuffer);
 
         bool generateKey(GenKeyInfo *params);
 
-        GpgKeyList listKeys();
-
         void deleteKeys(QStringList *uidList);
 
         bool encrypt(QStringList *uidList, const QByteArray &inBuffer,
@@ -104,9 +106,10 @@ namespace GpgME {
 
         void getKeyDetails(const QString &uid, GpgKey& key);
 
+        void signKey(const QVector<GpgKey> &signer, const GpgKey &target, const QString& uid);
+
         gpgme_signature_t verify(QByteArray *inBuffer, QByteArray *sigBuffer = nullptr);
 
-//    void decryptVerify(QByteArray in);
         bool sign(QStringList *uidList, const QByteArray &inBuffer, QByteArray *outBuffer, bool detached = false);
 
         /**
@@ -158,6 +161,8 @@ namespace GpgME {
         [[maybe_unused]] bool debug;
         GpgKeyList mKeyList;
 
+        void fetch_keys();
+
         static void checkErr(gpgme_error_t gpgmeError);
 
         static void checkErr(gpgme_error_t gpgmeError, const QString &comment);
diff --git a/include/gpg/GpgKey.h b/include/gpg/GpgKey.h
index 5d244510..835954f9 100644
--- a/include/gpg/GpgKey.h
+++ b/include/gpg/GpgKey.h
@@ -43,7 +43,7 @@ public:
     QDateTime expires;
     QDateTime create_time;
 
-    unsigned int length;
+    unsigned int length{};
 
     bool can_encrypt{};
     bool can_sign{};
@@ -62,13 +62,19 @@ public:
 
     QVector<UID> uids;
 
-    explicit GpgKey(gpgme_key_t key) {
-       parse(key);
-    }
+    gpgme_key_t key_refer = nullptr;
 
-    GpgKey() {
-        is_private_key = false;
-    }
+    explicit GpgKey(gpgme_key_t key = nullptr);
+
+    GpgKey(const GpgKey &k);
+
+    GpgKey(GpgKey &&k)  noexcept;
+
+    GpgKey& operator=(const GpgKey &k);
+
+    GpgKey& operator=(GpgKey &&k)  noexcept;
+
+    ~GpgKey();
 
     void parse(gpgme_key_t key);
 };
diff --git a/include/gpg/GpgSubKey.h b/include/gpg/GpgSubKey.h
index f495c709..229e04c9 100644
--- a/include/gpg/GpgSubKey.h
+++ b/include/gpg/GpgSubKey.h
@@ -50,31 +50,12 @@ struct GpgSubKey {
     QDateTime timestamp;
     QDateTime expires;
 
-    GpgSubKey() = default;
+    explicit GpgSubKey(gpgme_subkey_t key = nullptr);
 
-    explicit GpgSubKey(gpgme_subkey_t key) {
-
-        id = key->keyid;
-        pubkey_algo = gpgme_pubkey_algo_name(key->pubkey_algo);
-        fpr = key->fpr;
-
-        expired = (key->expired != 0u);
-        revoked = (key->revoked != 0u);
-
-        disabled = key->disabled;
-
-        length = key->length;
-
-        can_authenticate = key->can_authenticate;
-        can_certify = key->can_certify;
-        can_encrypt = key->can_encrypt;
-        can_sign = key->can_sign;
-        is_cardkey = key->is_cardkey;
-        is_private_key = key->secret;
-
-        timestamp = QDateTime::fromTime_t(key->timestamp);
-        expires = QDateTime::fromTime_t(key->expires);
-    }
+    GpgSubKey(GpgSubKey &&) noexcept = default;
+    GpgSubKey(const GpgSubKey &) = default;
+    GpgSubKey& operator=(GpgSubKey &&) noexcept = default;
+    GpgSubKey& operator=(const GpgSubKey &) = default;
 
 };
 
diff --git a/include/gpg/Signature.h b/include/gpg/Signature.h
index d361453d..3fa4414b 100644
--- a/include/gpg/Signature.h
+++ b/include/gpg/Signature.h
@@ -53,13 +53,12 @@ struct Signature {
 
     Signature() = default;
 
-    explicit Signature(gpgme_key_sig_t key_sig):
-        revoked(key_sig->revoked), expired(key_sig->expired), invalid(key_sig->invalid),
-        exportable(key_sig->exportable), pubkey_algo(gpgme_pubkey_algo_name(key_sig->pubkey_algo)),
-        name(key_sig->name), email(key_sig->email), comment(key_sig->comment),
-        create_time(QDateTime::fromTime_t(key_sig->timestamp)), expire_time(QDateTime::fromTime_t(key_sig->expires)){
+    explicit Signature(gpgme_key_sig_t key_sig);
 
-    }
+    Signature(Signature &&) noexcept = default;
+    Signature(const Signature &) = default;
+    Signature& operator=(Signature &&) noexcept = default;
+    Signature& operator=(const Signature &) = default;
 
 };
 
diff --git a/include/gpg/UID.h b/include/gpg/UID.h
index ecd361fd..d7a0f3bd 100644
--- a/include/gpg/UID.h
+++ b/include/gpg/UID.h
@@ -45,16 +45,13 @@ struct UID {
 
     UID() = default;
 
-    explicit UID(gpgme_user_id_t user_id):
-            uid(user_id->uid), name(user_id->name), email(user_id->email), comment(user_id->comment) {
+    explicit UID(gpgme_user_id_t user_id);
 
-        auto sig = user_id->signatures;
+    UID(UID &&) noexcept = default;
+    UID(const UID &) = default;
+    UID& operator=(UID &&) noexcept = default;
+    UID& operator=(const UID &) = default;
 
-        while (sig != nullptr) {
-            signatures.push_back(Signature(sig));
-        }
-
-    }
 };
 
 #endif //GPGFRONTEND_UID_H
\ No newline at end of file
diff --git a/release/icons/gpgfrontend-logo.png b/release/icons/gpgfrontend-logo.png
index 22381dbe..7e9841be 100644
--- a/release/icons/gpgfrontend-logo.png
+++ b/release/icons/gpgfrontend-logo.png
diff --git a/release/icons/gpgfrontend-logo_small.png b/release/icons/gpgfrontend-logo_small.png
index d574f533..d34c6c31 100644
--- a/release/icons/gpgfrontend-logo_small.png
+++ b/release/icons/gpgfrontend-logo_small.png
diff --git a/src/gpg/GpgContext.cpp b/src/gpg/GpgContext.cpp
index f7a7ea5c..2ca2f625 100644
--- a/src/gpg/GpgContext.cpp
+++ b/src/gpg/GpgContext.cpp
@@ -98,7 +98,7 @@ namespace GpgME {
             debug = false;
         }
 
-        connect(this, SIGNAL(signalKeyDBChanged()), this, SLOT(slotRefreshKeyList()));
+        connect(this, SIGNAL(signalKeyDBChanged()), this, SLOT(slotRefreshKeyList()), Qt::DirectConnection);
         slotRefreshKeyList();
     }
 
@@ -189,33 +189,33 @@ namespace GpgME {
         unsigned long expires = params->getExpired().toTime_t();
         unsigned int flags = 0;
 
-        if(!params->isSubKey()) {
+        if (!params->isSubKey()) {
             flags |= GPGME_CREATE_CERT;
         }
 
-        if(params->isAllowEncryption()) {
+        if (params->isAllowEncryption()) {
             flags |= GPGME_CREATE_ENCR;
         }
 
-        if(params->isAllowSigning()) {
+        if (params->isAllowSigning()) {
             flags |= GPGME_CREATE_SIGN;
         }
 
-        if(params->isAllowAuthentication()) {
+        if (params->isAllowAuthentication()) {
             flags |= GPGME_CREATE_AUTH;
         }
 
-        if(params->isNonExpired()) {
+        if (params->isNonExpired()) {
             flags |= GPGME_CREATE_NOEXPIRE;
         }
 
-        if(params->isNoPassPhrase()) {
+        if (params->isNoPassPhrase()) {
             flags |= GPGME_CREATE_NOPASSWD;
         }
 
-        err = gpgme_op_createkey(mCtx, userid, algo, 0, expires, nullptr,  flags);
+        err = gpgme_op_createkey(mCtx, userid, algo, 0, expires, nullptr, flags);
 
-        if(err != GPG_ERR_NO_ERROR) {
+        if (err != GPG_ERR_NO_ERROR) {
             checkErr(err);
             return false;
         } else {
@@ -253,7 +253,7 @@ namespace GpgME {
         return true;
     }
 
-    void GpgContext::getKeyDetails(const QString& uid, GpgKey& key) {
+    void GpgContext::getKeyDetails(const QString &uid, GpgKey &key) {
         gpgme_key_t gpgme_key;
 
         // try secret
@@ -266,31 +266,59 @@ namespace GpgME {
         key.parse(gpgme_key);
     }
 
-/** List all availabe Keys (VERY much like kgpgme)
- */
-    GpgKeyList GpgContext::listKeys() {
+    /**
+     * List all availabe Keys (VERY much like kgpgme)
+     */
+    void GpgContext::fetch_keys() {
+
         gpgme_error_t gpgmeError;
+
         gpgme_key_t key;
 
         GpgKeyList keys;
+
         //TODO dont run the loop more often than necessary
         // list all keys ( the 0 is for all )
         gpgmeError = gpgme_set_keylist_mode(mCtx, GPGME_KEYLIST_MODE_LOCAL | GPGME_KEYLIST_MODE_WITH_SECRET);
-        checkErr(gpgmeError);
+        if (gpgmeError != GPG_ERR_NO_ERROR) {
+            checkErr(gpgmeError);
+            return;
+        }
+
         gpgmeError = gpgme_op_keylist_start(mCtx, nullptr, 0);
-        checkErr(gpgmeError);
-        while (!(gpgmeError = gpgme_op_keylist_next(mCtx, &key))) {
+        if (gpgmeError != GPG_ERR_NO_ERROR) {
+            checkErr(gpgmeError);
+            return;
+        }
+
+        while ((gpgmeError = gpgme_op_keylist_next(mCtx, &key)) == GPG_ERR_NO_ERROR) {
             if (!key->subkeys)
                 continue;
 
             keys.append(GpgKey(key));
             gpgme_key_unref(key);
         }
-        gpgme_op_keylist_end(mCtx);
+
+
+//        if (gpgmeError != GPG_ERR_EOF) {
+//            checkErr(gpgmeError);
+//            return;
+//        }
+
+        gpgmeError = gpgme_op_keylist_end(mCtx);
+        if (gpgmeError != GPG_ERR_NO_ERROR) {
+            checkErr(gpgmeError);
+            return;
+        }
 
         // list only private keys ( the 1 does )
-        gpgme_op_keylist_start(mCtx, nullptr, 1);
-        while (!(gpgmeError = gpgme_op_keylist_next(mCtx, &key))) {
+        gpgmeError = gpgme_op_keylist_start(mCtx, nullptr, 1);
+        if (gpgmeError != GPG_ERR_NO_ERROR) {
+            checkErr(gpgmeError);
+            return;
+        }
+
+        while ((gpgmeError = gpgme_op_keylist_next(mCtx, &key)) == GPG_ERR_NO_ERROR) {
             if (!key->subkeys)
                 continue;
             // iterate keys, mark privates
@@ -300,27 +328,58 @@ namespace GpgME {
                     it->is_private_key = true;
                 it++;
             }
-
             gpgme_key_unref(key);
         }
-        gpgme_op_keylist_end(mCtx);
 
-        return keys;
+//        if (gpgmeError != GPG_ERR_EOF) {
+//            checkErr(gpgmeError);
+//            return;
+//        }
+
+        gpgmeError = gpgme_op_keylist_end(mCtx);
+        if (gpgmeError != GPG_ERR_NO_ERROR) {
+            checkErr(gpgmeError);
+            return;
+        }
+
+        mKeyList = keys;
     }
 
 /** Delete keys
  */
 
     void GpgContext::deleteKeys(QStringList *uidList) {
-        QString tmp;
+
+        gpgme_error_t error;
         gpgme_key_t key;
 
-                foreach(tmp, *uidList) {
-                gpgme_op_keylist_start(mCtx, tmp.toUtf8().constData(), 0);
-                gpgme_op_keylist_next(mCtx, &key);
-                gpgme_op_keylist_end(mCtx);
-                gpgme_op_delete(mCtx, key, 1);
+        for (const auto &tmp : *uidList) {
+
+            error = gpgme_op_keylist_start(mCtx, tmp.toUtf8().constData(), 0);
+            if (error != GPG_ERR_NO_ERROR) {
+                checkErr(error);
+                continue;
+            }
+
+            error = gpgme_op_keylist_next(mCtx, &key);
+            if (error != GPG_ERR_NO_ERROR) {
+                checkErr(error);
+                continue;
+            }
+
+            error = gpgme_op_keylist_end(mCtx);
+            if (error != GPG_ERR_NO_ERROR) {
+                checkErr(error);
+                continue;
+            }
+
+            error = gpgme_op_delete(mCtx, key, 1);
+            if (error != GPG_ERR_NO_ERROR) {
+                checkErr(error);
+                continue;
             }
+
+        }
         emit signalKeyDBChanged();
     }
 
@@ -405,7 +464,8 @@ namespace GpgME {
                         checkErr(result->recipients->status);
                         errorString.append(gpgErrString(result->recipients->status)).append("<br>");
                         errorString.append(
-                                tr("<br>No private key with id %1 present dataIn keyring").arg(result->recipients->keyid));
+                                tr("<br>No private key with id %1 present dataIn keyring").arg(
+                                        result->recipients->keyid));
                     } else {
                         errorString.append(gpgErrString(err)).append("<br>");
                     }
@@ -551,19 +611,19 @@ namespace GpgME {
     }
 
 // error-handling
-    void GpgContext::checkErr(gpgme_error_t gpgmeError, const QString& comment) {
+    void GpgContext::checkErr(gpgme_error_t gpgmeError, const QString &comment) {
         //if (gpgmeError != GPG_ERR_NO_ERROR && gpgmeError != GPG_ERR_CANCELED) {
         if (gpgmeError != GPG_ERR_NO_ERROR) {
-            qDebug() << "[Error "<< gpg_err_code(gpgmeError)
-                     <<"] Source: " << gpgme_strsource(gpgmeError) << " Description: " << gpgErrString(gpgmeError);
+            qDebug() << "[Error " << gpg_err_code(gpgmeError)
+                     << "] Source: " << gpgme_strsource(gpgmeError) << " Description: " << gpgErrString(gpgmeError);
         }
     }
 
     void GpgContext::checkErr(gpgme_error_t gpgmeError) {
         //if (gpgmeError != GPG_ERR_NO_ERROR && gpgmeError != GPG_ERR_CANCELED) {
         if (gpgmeError != GPG_ERR_NO_ERROR) {
-            qDebug() << "[Error "<< gpg_err_code(gpgmeError)
-            <<"] Source: " << gpgme_strsource(gpgmeError) << " Description: " << gpgErrString(gpgmeError);
+            qDebug() << "[Error " << gpg_err_code(gpgmeError)
+                     << "] Source: " << gpgme_strsource(gpgmeError) << " Description: " << gpgErrString(gpgmeError);
         }
     }
 
@@ -573,7 +633,7 @@ namespace GpgME {
 
 /** export private key, TODO errohandling, e.g. like in seahorse (seahorse-gpg-op.c) **/
 
-    void GpgContext::exportSecretKey(const QString& uid, QByteArray *outBuffer) {
+    void GpgContext::exportSecretKey(const QString &uid, QByteArray *outBuffer) {
         qDebug() << *outBuffer;
         // export private key to outBuffer
         QStringList arguments;
@@ -590,7 +650,7 @@ namespace GpgME {
     }
 
 /** return type should be gpgme_error_t*/
-    void GpgContext::executeGpgCommand(const QStringList& arguments, QByteArray *stdOut, QByteArray *stdErr) {
+    void GpgContext::executeGpgCommand(const QStringList &arguments, QByteArray *stdOut, QByteArray *stdErr) {
         QStringList args;
         args << "--homedir" << gpgKeys << "--batch" << arguments;
 
@@ -789,43 +849,48 @@ namespace GpgME {
     }
 
     void GpgContext::slotRefreshKeyList() {
-        mKeyList = this->listKeys();
+        this->fetch_keys();
     }
 
 /**
  * note: is_private_key status is not returned
  */
-    GpgKey GpgContext::getKeyByFpr(const QString& fpr) {
-
-        //GpgKeyList list = this->listKeys();
-                foreach  (GpgKey key, mKeyList) {
-                if (key.fpr == fpr) {
-                    return key;
-                }
+    GpgKey GpgContext::getKeyByFpr(const QString &fpr) {
+        for (const auto &key : mKeyList) {
+            if (key.fpr == fpr) {
+                return key;
             }
-
-        return GpgKey();
+        }
+        return GpgKey(nullptr);
     }
 
 /**
  * note: is_private_key status is not returned
  */
-    GpgKey GpgContext::getKeyById(const QString& id) {
+    GpgKey GpgContext::getKeyById(const QString &id) {
 
-        //GpgKeyList list = this->listKeys();
+        //GpgKeyList list = this->fetch_keys();
                 foreach  (GpgKey key, mKeyList) {
                 if (key.id == id) {
                     return key;
                 }
             }
 
-        return GpgKey();
+        return GpgKey(nullptr);
     }
 
     QString GpgContext::getGpgmeVersion() {
         return QString(gpgme_check_version(nullptr));
     }
 
+    void GpgContext::signKey(const QVector<GpgKey> &signer, const GpgKey &target, const QString &uid) {
+
+    }
+
+    const GpgKeyList &GpgContext::getKeys() const {
+        return mKeyList;
+    }
+
 }
 
 
diff --git a/src/gpg/GpgKey.cpp b/src/gpg/GpgKey.cpp
index c1116f24..51ab2158 100644
--- a/src/gpg/GpgKey.cpp
+++ b/src/gpg/GpgKey.cpp
@@ -25,73 +25,230 @@
 #include "gpg/GpgKey.h"
 
 void GpgKey::parse(gpgme_key_t key) {
-    if(key != nullptr) {
-        good = true;
-        is_private_key = key->secret;
-        fpr = key->fpr;
-        protocol = key->protocol;
-        expired = (key->expired != 0u);
-        revoked = (key->revoked != 0u);
-
-        disabled = key->disabled;
-
-        can_authenticate = key->can_authenticate;
-        can_certify = key->can_certify;
-        can_encrypt = key->can_encrypt;
-        can_sign = key->can_sign;
-
-        last_update = QDateTime(QDateTime::fromTime_t(key->last_update));
-
-        switch (key->owner_trust) {
-            case GPGME_VALIDITY_UNKNOWN:
-                owner_trust = "Unknown";
-                break;
-            case GPGME_VALIDITY_UNDEFINED:
-                owner_trust = "Undefined";
-                break;
-            case GPGME_VALIDITY_NEVER:
-                owner_trust = "Never";
-                break;
-            case GPGME_VALIDITY_MARGINAL:
-                owner_trust = "Marginal";
-                break;
-            case GPGME_VALIDITY_FULL:
-                owner_trust = "FULL";
-                break;
-            case GPGME_VALIDITY_ULTIMATE:
-                owner_trust = "Ultimate";
-                break;
-        }
-
-        auto uid = key->uids;
-
-        while(uid != nullptr) {
-            uids.push_back(UID(uid));
-            uid = uid->next;
-        }
-
-
-        if (!uids.isEmpty()) {
-            name = uids.first().name;
-            email = uids.first().email;
-            comment = uids.first().comment;
-        }
-
-        auto next = key->subkeys;
-
-        while (next != nullptr) {
-            subKeys.push_back(GpgSubKey(next));
-            next = next->next;
-        }
-
-        if (!subKeys.isEmpty()) {
-            id = subKeys.first().id;
-            expires = subKeys.first().expires;
-            pubkey_algo = subKeys.first().pubkey_algo;
-            create_time = subKeys.first().timestamp;
-            length = subKeys.first().length;
-        } else {
-            id = "";
-        }
+
+    if(key == nullptr) return;
+
+    good = true;
+    key_refer = key;
+    gpgme_key_ref(key_refer);
+
+    is_private_key = key->secret;
+    fpr = key->fpr;
+    protocol = key->protocol;
+    expired = (key->expired != 0u);
+    revoked = (key->revoked != 0u);
+
+    disabled = key->disabled;
+
+    can_authenticate = key->can_authenticate;
+    can_certify = key->can_certify;
+    can_encrypt = key->can_encrypt;
+    can_sign = key->can_sign;
+
+    last_update = QDateTime(QDateTime::fromTime_t(key->last_update));
+
+    switch (key->owner_trust) {
+        case GPGME_VALIDITY_UNKNOWN:
+            owner_trust = "Unknown";
+            break;
+        case GPGME_VALIDITY_UNDEFINED:
+            owner_trust = "Undefined";
+            break;
+        case GPGME_VALIDITY_NEVER:
+            owner_trust = "Never";
+            break;
+        case GPGME_VALIDITY_MARGINAL:
+            owner_trust = "Marginal";
+            break;
+        case GPGME_VALIDITY_FULL:
+            owner_trust = "FULL";
+            break;
+        case GPGME_VALIDITY_ULTIMATE:
+            owner_trust = "Ultimate";
+            break;
     }
+
+    auto uid = key->uids;
+
+    while (uid != nullptr) {
+        uids.push_back(UID(uid));
+        uid = uid->next;
+    }
+
+
+    if (!uids.isEmpty()) {
+        name = uids.first().name;
+        email = uids.first().email;
+        comment = uids.first().comment;
+    }
+
+    auto next = key->subkeys;
+
+    while (next != nullptr) {
+        subKeys.push_back(GpgSubKey(next));
+        next = next->next;
+    }
+
+    if (!subKeys.isEmpty()) {
+        id = subKeys.first().id;
+        expires = subKeys.first().expires;
+        pubkey_algo = subKeys.first().pubkey_algo;
+        create_time = subKeys.first().timestamp;
+        length = subKeys.first().length;
+    } else {
+        id = "";
+    }
+
+}
+
+GpgKey::GpgKey(GpgKey &&k) noexcept {
+
+    id = std::move(k.id);
+    name = std::move(k.name);
+    email = std::move(k.email);
+    comment = std::move(k.comment);
+    fpr = std::move(k.fpr);
+    protocol = std::move(k.protocol);
+    owner_trust = std::move(k.owner_trust);
+    pubkey_algo = std::move(k.pubkey_algo);
+    last_update = std::move(k.last_update);
+    expires = std::move(k.expires);
+    create_time = std::move(k.create_time);
+
+    length = k.length;
+    k.length = 0;
+
+    can_encrypt = k.can_encrypt;
+    can_sign = k.can_sign;
+    can_certify = k.can_certify;
+    can_authenticate = k.can_authenticate;
+
+
+    is_private_key = k.is_private_key;
+    expired = k.expired;
+    revoked = k.revoked;
+    disabled = k.disabled;
+
+    good = k.good;
+    k.good = false;
+
+    subKeys = std::move(k.subKeys);
+    uids = std::move(k.uids);
+
+    key_refer = k.key_refer;
+    k.key_refer = nullptr;
+
+}
+
+GpgKey &GpgKey::operator=(const GpgKey &k) {
+
+    id = k.id;
+    name = k.name;
+    email = k.email;
+    comment = k.comment;
+    fpr = k.fpr;
+    protocol = k.protocol;
+    owner_trust = k.owner_trust;
+    pubkey_algo = k.pubkey_algo;
+    last_update = k.last_update;
+    expires = k.expires;
+    create_time = k.create_time;
+
+    length = k.length;
+
+    can_encrypt = k.can_encrypt;
+    can_sign = k.can_sign;
+    can_certify = k.can_certify;
+    can_authenticate = k.can_authenticate;
+
+    is_private_key = k.is_private_key;
+    expired = k.expired;
+    revoked = k.revoked;
+    disabled = k.disabled;
+
+    good = k.good;
+
+    subKeys = k.subKeys;
+
+    key_refer = k.key_refer;
+    gpgme_key_ref(key_refer);
+
+    return *this;
+}
+
+GpgKey::GpgKey(const GpgKey &k) :
+        id(k.id), name(k.name), email(k.email), comment(k.comment),
+        fpr(k.fpr), protocol(k.protocol), owner_trust(k.owner_trust),
+        pubkey_algo(k.pubkey_algo), last_update(k.last_update),
+        expires(k.expires), create_time(k.create_time){
+
+    length = k.length;
+
+    can_encrypt = k.can_encrypt;
+    can_sign = k.can_sign;
+    can_certify = k.can_certify;
+    can_authenticate = k.can_authenticate;
+
+    is_private_key = k.is_private_key;
+    expired = k.expired;
+    revoked = k.revoked;
+    disabled = k.disabled;
+
+    good = k.good;
+
+    subKeys = k.subKeys;
+
+    key_refer = k.key_refer;
+    gpgme_key_ref(key_refer);
+
+}
+
+GpgKey &GpgKey::operator=(GpgKey &&k) noexcept {
+
+    id = std::move(k.id);
+    name = std::move(k.name);
+    email = std::move(k.email);
+    comment = std::move(k.comment);
+    fpr = std::move(k.fpr);
+    protocol = std::move(k.protocol);
+    owner_trust = std::move(k.owner_trust);
+    pubkey_algo = std::move(k.pubkey_algo);
+    last_update = std::move(k.last_update);
+    expires = std::move(k.expires);
+    create_time = std::move(k.create_time);
+
+    length = k.length;
+    k.length = 0;
+
+    can_encrypt = k.can_encrypt;
+    can_sign = k.can_sign;
+    can_certify = k.can_certify;
+    can_authenticate = k.can_authenticate;
+
+
+    is_private_key = k.is_private_key;
+    expired = k.expired;
+    revoked = k.revoked;
+    disabled = k.disabled;
+
+    good = k.good;
+    k.good = false;
+
+    subKeys = std::move(k.subKeys);
+    uids = std::move(k.uids);
+
+    key_refer = k.key_refer;
+    k.key_refer = nullptr;
+
+    return *this;
+}
+
+GpgKey::~GpgKey() {
+    if(key_refer != nullptr && good) {
+        gpgme_key_unref(key_refer);
+    }
+}
+
+GpgKey::GpgKey(gpgme_key_t key) {
+    parse(key);
 }
diff --git a/src/gpg/GpgSubKey.cpp b/src/gpg/GpgSubKey.cpp
index e63c3139..0f8e279f 100644
--- a/src/gpg/GpgSubKey.cpp
+++ b/src/gpg/GpgSubKey.cpp
@@ -22,3 +22,29 @@
  *
  */
 #include "gpg/GpgSubKey.h"
+
+GpgSubKey::GpgSubKey(gpgme_subkey_t key) {
+
+    if (key == nullptr) return;
+
+    id = key->keyid;
+    pubkey_algo = gpgme_pubkey_algo_name(key->pubkey_algo);
+    fpr = key->fpr;
+
+    expired = (key->expired != 0u);
+    revoked = (key->revoked != 0u);
+
+    disabled = key->disabled;
+
+    length = key->length;
+
+    can_authenticate = key->can_authenticate;
+    can_certify = key->can_certify;
+    can_encrypt = key->can_encrypt;
+    can_sign = key->can_sign;
+    is_cardkey = key->is_cardkey;
+    is_private_key = key->secret;
+
+    timestamp = QDateTime::fromTime_t(key->timestamp);
+    expires = QDateTime::fromTime_t(key->expires);
+}
diff --git a/src/gpg/Signature.cpp b/src/gpg/Signature.cpp
index 9e7f0574..f9762501 100644
--- a/src/gpg/Signature.cpp
+++ b/src/gpg/Signature.cpp
@@ -23,3 +23,11 @@
  */
 
 #include "gpg/Signature.h"
+
+Signature::Signature(gpgme_key_sig_t key_sig) :
+        revoked(key_sig->revoked), expired(key_sig->expired), invalid(key_sig->invalid),
+        exportable(key_sig->exportable), pubkey_algo(gpgme_pubkey_algo_name(key_sig->pubkey_algo)),
+        name(key_sig->name), email(key_sig->email), comment(key_sig->comment),
+        create_time(QDateTime::fromTime_t(key_sig->timestamp)), expire_time(QDateTime::fromTime_t(key_sig->expires)){
+
+}
diff --git a/src/gpg/UID.cpp b/src/gpg/UID.cpp
new file mode 100644
index 00000000..a1147eec
--- /dev/null
+++ b/src/gpg/UID.cpp
@@ -0,0 +1,16 @@
+//
+// Created by eric on 2021/5/22.
+//
+
+#include "gpg/UID.h"
+
+UID::UID(gpgme_user_id_t user_id) :
+        uid(user_id->uid), name(user_id->name), email(user_id->email), comment(user_id->comment) {
+
+    auto sig = user_id->signatures;
+
+    while (sig != nullptr) {
+        signatures.push_back(Signature(sig));
+    }
+
+}
\ No newline at end of file
diff --git a/src/ui/KeyImportDetailDialog.cpp b/src/ui/KeyImportDetailDialog.cpp
index 2533cfb0..4c60ad0f 100644
--- a/src/ui/KeyImportDetailDialog.cpp
+++ b/src/ui/KeyImportDetailDialog.cpp
@@ -106,15 +106,16 @@ void KeyImportDetailDialog::createKeysTable() {
 
     keysTable->setHorizontalHeaderLabels(headerLabels);
     int row = 0;
-            foreach (GpgImportedKey impKey, mResult.importedKeys) {
-            keysTable->setRowCount(row + 1);
-            GpgKey key = mCtx->getKeyByFpr(impKey.fpr);
-            keysTable->setItem(row, 0, new QTableWidgetItem(key.name));
-            keysTable->setItem(row, 1, new QTableWidgetItem(key.email));
-            keysTable->setItem(row, 2, new QTableWidgetItem(getStatusString(impKey.importStatus)));
-            keysTable->setItem(row, 3, new QTableWidgetItem(impKey.fpr));
-            row++;
-        }
+    for (const auto &impKey : mResult.importedKeys) {
+        keysTable->setRowCount(row + 1);
+        GpgKey key = mCtx->getKeyByFpr(impKey.fpr);
+        if(!key.good) continue;
+        keysTable->setItem(row, 0, new QTableWidgetItem(key.name));
+        keysTable->setItem(row, 1, new QTableWidgetItem(key.email));
+        keysTable->setItem(row, 2, new QTableWidgetItem(getStatusString(impKey.importStatus)));
+        keysTable->setItem(row, 3, new QTableWidgetItem(impKey.fpr));
+        row++;
+    }
     keysTable->horizontalHeader()->setSectionResizeMode(0, QHeaderView::ResizeToContents);
     keysTable->horizontalHeader()->setStretchLastSection(true);
     keysTable->resizeColumnsToContents();
diff --git a/src/ui/KeyList.cpp b/src/ui/KeyList.cpp
index 6931dc8d..c21a41ff 100644
--- a/src/ui/KeyList.cpp
+++ b/src/ui/KeyList.cpp
@@ -73,7 +73,7 @@ void KeyList::slotRefresh()
     mKeyList->setSortingEnabled(false);
     mKeyList->clearContents();
 
-    GpgKeyList keys = mCtx->listKeys();
+    GpgKeyList keys = mCtx->getKeys();
     mKeyList->setRowCount(keys.size());
 
     int row = 0;
diff --git a/src/ui/KeyMgmt.cpp b/src/ui/KeyMgmt.cpp
index 1078778e..b1699483 100755
--- a/src/ui/KeyMgmt.cpp
+++ b/src/ui/KeyMgmt.cpp
@@ -233,7 +233,7 @@ void KeyMgmt::deleteKeysWithWarning(QStringList *uidList)
         return;
     }
     QString keynames;
-    foreach (QString uid, *uidList) {
+    for (const auto &uid : *uidList) {
         GpgKey key;
         mCtx->getKeyDetails(uid, key);
         keynames.append(key.name);
diff --git a/src/ui/VerifyKeyDetailBox.cpp b/src/ui/VerifyKeyDetailBox.cpp
index fda67d55..57f70a62 100644
--- a/src/ui/VerifyKeyDetailBox.cpp
+++ b/src/ui/VerifyKeyDetailBox.cpp
@@ -50,6 +50,8 @@ VerifyKeyDetailBox::VerifyKeyDetailBox(QWidget *parent, GpgME::GpgContext *ctx,
         case GPG_ERR_NO_ERROR: {
             GpgKey key = mCtx->getKeyByFpr(signature->fpr);
 
+            if(!key.good) break;
+
             this->setTitle(key.name);
             grid->addWidget(new QLabel(tr("Name:")), 0, 0);
             grid->addWidget(new QLabel(tr("EMail:")), 1, 0);
@@ -65,6 +67,9 @@ VerifyKeyDetailBox::VerifyKeyDetailBox(QWidget *parent, GpgME::GpgContext *ctx,
         }
         default: {
             GpgKey key = mCtx->getKeyById(signature->fpr);
+
+            if(!key.good) break;
+
             this->setTitle(tr("Error for key with id 0x") + fpr);
             grid->addWidget(new QLabel(tr("Name:")), 0, 0);
             grid->addWidget(new QLabel(tr("EMail:")), 1, 0);
diff --git a/src/ui/VerifyNotification.cpp b/src/ui/VerifyNotification.cpp
index 3111a39f..b5b2c890 100644
--- a/src/ui/VerifyNotification.cpp
+++ b/src/ui/VerifyNotification.cpp
@@ -131,6 +131,9 @@ bool VerifyNotification::slotRefresh() {
                 textIsSigned = 3;
                 verifyStatus = VERIFY_ERROR_CRITICAL;
                 GpgKey key = mCtx->getKeyById(sign->fpr);
+
+                if(!key.good) break;
+
                 verifyLabelText.append(key.name);
                 if (!key.email.isEmpty()) {
                     verifyLabelText.append("<" + key.email + ">");
diff --git a/src/ui/keypair_details/KeyPairUIDTab.cpp b/src/ui/keypair_details/KeyPairUIDTab.cpp
index e0128b55..8ca68d60 100644
--- a/src/ui/keypair_details/KeyPairUIDTab.cpp
+++ b/src/ui/keypair_details/KeyPairUIDTab.cpp
@@ -93,8 +93,10 @@ void KeyPairUIDTab::slotRefreshUIDList() {
 
     uidList->clearContents();
     uidList->setRowCount(key.uids.size());
+    uidList->setSelectionMode(QAbstractItemView::SingleSelection);
 
     for(const auto& uid : key.uids) {
+
         auto *tmp0 = new QTableWidgetItem(uid.name);
         uidList->setItem(row, 0, tmp0);
 
@@ -108,6 +110,8 @@ void KeyPairUIDTab::slotRefreshUIDList() {
     }
 
 
+
+
 }
 
 void KeyPairUIDTab::slotRefreshSigList() {
@@ -122,6 +126,11 @@ void KeyPairUIDTab::slotRefreshSigList() {
 
     row = 0;
     for(const auto& uid : key.uids) {
+
+        // Only Show Selected UID's Signatures
+        if(!uidList->item(row, 0)->isSelected())
+            continue;
+
         for(const auto &sig : uid.signatures) {
             auto *tmp0 = new QTableWidgetItem(sig.pubkey_algo);
             uidList->setItem(row, 0, tmp0);