1 files changed, 121 insertions, 61 deletions

diff --git a/src/ui/KeyMgmt.cpp b/src/ui/KeyMgmt.cpp
index c03b8e6b..3715b01a 100755
--- a/src/ui/KeyMgmt.cpp
+++ b/src/ui/KeyMgmt.cpp
@@ -27,20 +27,23 @@
 #include <utility>
 
 #include "gpg/function/GpgKeyGetter.h"
-#include "gpg/function/GpgKeyImportExportor.h"
+#include "gpg/function/GpgKeyImportExporter.h"
 #include "gpg/function/GpgKeyOpera.h"
 #include "ui/SignalStation.h"
 #include "ui/UserInterfaceUtils.h"
+#include "ui/aes/qaesencryption.h"
+#include "ui/keygen/SubkeyGenerateDialog.h"
 #include "ui/settings/GlobalSettingStation.h"
+#include "ui/widgets/ExportKeyPackageDialog.h"
 
 namespace GpgFrontend::UI {
 KeyMgmt::KeyMgmt(QWidget* parent) : QMainWindow(parent) {
   /* the list of Keys available*/
-  mKeyList = new KeyList(true, this);
+  key_list_ = new KeyList(KeyMenuAbility::ALL, this);
 
-  mKeyList->addListGroupTab(_("All"), KeyListRow::SECRET_OR_PUBLIC_KEY);
+  key_list_->addListGroupTab(_("All"), KeyListRow::SECRET_OR_PUBLIC_KEY);
 
-  mKeyList->addListGroupTab(
+  key_list_->addListGroupTab(
       _("Only Public Key"), KeyListRow::SECRET_OR_PUBLIC_KEY,
       KeyListColumn::TYPE | KeyListColumn::NAME | KeyListColumn::EmailAddress |
           KeyListColumn::Usage | KeyListColumn::Validity,
@@ -49,7 +52,7 @@ KeyMgmt::KeyMgmt(QWidget* parent) : QMainWindow(parent) {
                !(key.revoked() || key.disabled() || key.expired());
       });
 
-  mKeyList->addListGroupTab(
+  key_list_->addListGroupTab(
       _("Has Private Key"), KeyListRow::SECRET_OR_PUBLIC_KEY,
       KeyListColumn::TYPE | KeyListColumn::NAME | KeyListColumn::EmailAddress |
           KeyListColumn::Usage | KeyListColumn::Validity,
@@ -58,8 +61,8 @@ KeyMgmt::KeyMgmt(QWidget* parent) : QMainWindow(parent) {
                !(key.revoked() || key.disabled() || key.expired());
       });
 
-  mKeyList->addListGroupTab(
-      _("No Master Key"), KeyListRow::SECRET_OR_PUBLIC_KEY,
+  key_list_->addListGroupTab(
+      _("No Primary Key"), KeyListRow::SECRET_OR_PUBLIC_KEY,
       KeyListColumn::TYPE | KeyListColumn::NAME | KeyListColumn::EmailAddress |
           KeyListColumn::Usage | KeyListColumn::Validity,
       [](const GpgKey& key) -> bool {
@@ -67,24 +70,24 @@ KeyMgmt::KeyMgmt(QWidget* parent) : QMainWindow(parent) {
                !(key.revoked() || key.disabled() || key.expired());
       });
 
-  mKeyList->addListGroupTab(
+  key_list_->addListGroupTab(
       _("Revoked"), KeyListRow::SECRET_OR_PUBLIC_KEY,
       KeyListColumn::TYPE | KeyListColumn::NAME | KeyListColumn::EmailAddress |
           KeyListColumn::Usage | KeyListColumn::Validity,
       [](const GpgKey& key) -> bool { return key.revoked(); });
 
-  mKeyList->addListGroupTab(
+  key_list_->addListGroupTab(
       _("Expired"), KeyListRow::SECRET_OR_PUBLIC_KEY,
       KeyListColumn::TYPE | KeyListColumn::NAME | KeyListColumn::EmailAddress |
           KeyListColumn::Usage | KeyListColumn::Validity,
       [](const GpgKey& key) -> bool { return key.expired(); });
 
-  setCentralWidget(mKeyList);
-  mKeyList->setDoubleClickedAction([this](const GpgKey& key, QWidget* parent) {
+  setCentralWidget(key_list_);
+  key_list_->setDoubleClickedAction([this](const GpgKey& key, QWidget* parent) {
     new KeyDetailsDialog(key, parent);
   });
 
-  mKeyList->slotRefresh();
+  key_list_->slotRefresh();
 
   createActions();
   createMenus();
@@ -141,18 +144,16 @@ KeyMgmt::KeyMgmt(QWidget* parent) : QMainWindow(parent) {
 
   this->resize(size);
   this->move(pos);
-  this->setWindowModality(Qt::ApplicationModal);
   this->statusBar()->show();
 
   setWindowTitle(_("KeyPair Management"));
-  mKeyList->addMenuAction(deleteSelectedKeysAct);
-  mKeyList->addMenuAction(showKeyDetailsAct);
+  key_list_->addMenuAction(deleteSelectedKeysAct);
+  key_list_->addMenuAction(showKeyDetailsAct);
 
   connect(this, SIGNAL(signalKeyStatusUpdated()), SignalStation::GetInstance(),
           SIGNAL(KeyDatabaseRefresh()));
-  connect(SignalStation::GetInstance(),
-          &SignalStation::signalRefreshStatusBar, this,
-          [=](const QString& message, int timeout) {
+  connect(SignalStation::GetInstance(), &SignalStation::signalRefreshStatusBar,
+          this, [=](const QString& message, int timeout) {
             statusBar()->showMessage(message, timeout);
           });
 }
@@ -204,17 +205,24 @@ void KeyMgmt::createActions() {
     CommonUtils::GetInstance()->slotImportKeyFromKeyServer(this);
   });
 
+  importKeysFromKeyPackageAct = new QAction(_("Key Package"), this);
+  importKeysFromKeyPackageAct->setIcon(QIcon(":key_package.png"));
+  importKeysFromKeyPackageAct->setToolTip(
+      _("Import Key(s) From a Key Package"));
+  connect(importKeysFromKeyPackageAct, &QAction::triggered, this,
+          &KeyMgmt::slotImportKeyPackage);
+
   exportKeyToClipboardAct = new QAction(_("Export To Clipboard"), this);
   exportKeyToClipboardAct->setIcon(QIcon(":export_key_to_clipboard.png"));
   exportKeyToClipboardAct->setToolTip(_("Export Selected Key(s) To Clipboard"));
   connect(exportKeyToClipboardAct, SIGNAL(triggered()), this,
           SLOT(slotExportKeyToClipboard()));
 
-  exportKeyToFileAct = new QAction(_("Export To File"), this);
-  exportKeyToFileAct->setIcon(QIcon(":export_key_to_file.png"));
-  exportKeyToFileAct->setToolTip(_("Export Selected Key(s) To File"));
+  exportKeyToFileAct = new QAction(_("Export To Key Package"), this);
+  exportKeyToFileAct->setIcon(QIcon(":key_package.png"));
+  exportKeyToFileAct->setToolTip(_("Export Checked Key(s) To a Key Package"));
   connect(exportKeyToFileAct, SIGNAL(triggered()), this,
-          SLOT(slotExportKeyToFile()));
+          SLOT(slotExportKeyToKeyPackage()));
 
   exportKeyAsOpenSSHFormat = new QAction(_("Export As OpenSSH"), this);
   exportKeyAsOpenSSHFormat->setIcon(QIcon(":ssh-key.png"));
@@ -254,6 +262,7 @@ void KeyMgmt::createMenus() {
   importKeyMenu->addAction(importKeyFromFileAct);
   importKeyMenu->addAction(importKeyFromClipboardAct);
   importKeyMenu->addAction(importKeyFromKeyServerAct);
+  importKeyMenu->addAction(importKeysFromKeyPackageAct);
 
   keyMenu->addAction(exportKeyToFileAct);
   keyMenu->addAction(exportKeyToClipboardAct);
@@ -295,11 +304,11 @@ void KeyMgmt::createToolBars() {
 }
 
 void KeyMgmt::slotDeleteSelectedKeys() {
-  deleteKeysWithWarning(mKeyList->getSelected());
+  deleteKeysWithWarning(key_list_->getSelected());
 }
 
 void KeyMgmt::slotDeleteCheckedKeys() {
-  deleteKeysWithWarning(mKeyList->getChecked());
+  deleteKeysWithWarning(key_list_->getChecked());
 }
 
 void KeyMgmt::deleteKeysWithWarning(KeyIdArgsListPtr key_ids) {
@@ -308,8 +317,6 @@ void KeyMgmt::deleteKeysWithWarning(KeyIdArgsListPtr key_ids) {
    * more than one selected... compare to seahorse "delete-dialog"
    */
 
-  LOG(INFO) << "KeyMgmt::deleteKeysWithWarning Called";
-
   if (key_ids->empty()) return;
   QString keynames;
   for (const auto& key_id : *key_ids) {
@@ -337,48 +344,44 @@ void KeyMgmt::deleteKeysWithWarning(KeyIdArgsListPtr key_ids) {
 }
 
 void KeyMgmt::slotShowKeyDetails() {
-  auto keys_selected = mKeyList->getSelected();
+  auto keys_selected = key_list_->getSelected();
   if (keys_selected->empty()) return;
 
   auto key = GpgKeyGetter::GetInstance().GetKey(keys_selected->front());
 
   if (!key.good()) {
-    QMessageBox::critical(nullptr, _("Error"), _("Key Not Found."));
+    QMessageBox::critical(this, _("Error"), _("Key Not Found."));
     return;
   }
 
   new KeyDetailsDialog(key);
 }
 
-void KeyMgmt::slotExportKeyToFile() {
-  ByteArrayPtr key_export_data = nullptr;
-  auto keys_checked = mKeyList->getChecked();
-  if (!GpgKeyImportExportor::GetInstance().ExportKeys(keys_checked,
-                                                      key_export_data)) {
-    return;
-  }
-  auto key =
-      GpgKeyGetter::GetInstance().GetKey(mKeyList->getSelected()->front());
-  if (!key.good()) {
-    QMessageBox::critical(nullptr, _("Error"), _("Key Not Found."));
+void KeyMgmt::slotExportKeyToKeyPackage() {
+  auto keys_checked = key_list_->getChecked();
+  if (keys_checked->empty()) {
+    QMessageBox::critical(
+        this, _("Forbidden"),
+        _("Please check some keys before doing this operation."));
     return;
   }
-  QString fileString = QString::fromStdString(key.name() + " " + key.email() +
-                                              "(" + key.id() + ")_pub.asc");
-
-  QString file_name = QFileDialog::getSaveFileName(
-      this, _("Export Key To File"), fileString,
-      QString(_("Key Files")) + " (*.asc *.txt);;All Files (*)");
-
-  write_buffer_to_file(file_name.toStdString(), *key_export_data);
-
+  auto dialog = new ExportKeyPackageDialog(std::move(keys_checked), this);
+  dialog->exec();
   emit signalStatusBarChanged(QString(_("key(s) exported")));
 }
 
 void KeyMgmt::slotExportKeyToClipboard() {
+
+  auto keys_checked = key_list_->getChecked();
+  if (keys_checked->empty()) {
+    QMessageBox::critical(
+        this, _("Forbidden"),
+        _("Please check some keys before doing this operation."));
+    return;
+  }
+
   ByteArrayPtr key_export_data = nullptr;
-  auto keys_checked = mKeyList->getChecked();
-  if (!GpgKeyImportExportor::GetInstance().ExportKeys(keys_checked,
+  if (!GpgKeyImportExporter::GetInstance().ExportKeys(keys_checked,
                                                       key_export_data)) {
     return;
   }
@@ -396,20 +399,20 @@ void KeyMgmt::closeEvent(QCloseEvent* event) {
 }
 
 void KeyMgmt::slotGenerateSubKey() {
-  auto keys_selected = mKeyList->getSelected();
+  auto keys_selected = key_list_->getSelected();
   if (keys_selected->empty()) {
     QMessageBox::information(
-        nullptr, _("Invalid Operation"),
+        this, _("Invalid Operation"),
         _("Please select one KeyPair before doing this operation."));
     return;
   }
   const auto key = GpgKeyGetter::GetInstance().GetKey(keys_selected->front());
   if (!key.good()) {
-    QMessageBox::critical(nullptr, _("Error"), _("Key Not Found."));
+    QMessageBox::critical(this, _("Error"), _("Key Not Found."));
     return;
   }
   if (!key.is_private_key()) {
-    QMessageBox::critical(nullptr, _("Invalid Operation"),
+    QMessageBox::critical(this, _("Invalid Operation"),
                           _("If a key pair does not have a private key then "
                             "it will not be able to generate sub-keys."));
     return;
@@ -467,24 +470,26 @@ void KeyMgmt::slotSaveWindowState() {
 
 void KeyMgmt::slotExportAsOpenSSHFormat() {
   ByteArrayPtr key_export_data = nullptr;
-  auto keys_checked = mKeyList->getChecked();
+  auto keys_checked = key_list_->getChecked();
 
   if (keys_checked->empty()) {
-    QMessageBox::critical(nullptr, _("Error"), _("No Key Checked."));
+    QMessageBox::critical(
+        this, _("Forbidden"),
+        _("Please select a key before performing this operation. If you select "
+          "multiple keys, only the first key will be exported."));
     return;
   }
 
   auto key = GpgKeyGetter::GetInstance().GetKey(keys_checked->front());
-  if (!GpgKeyImportExportor::GetInstance().ExportKeyOpenSSH(key,
+  if (!GpgKeyImportExporter::GetInstance().ExportKeyOpenSSH(key,
                                                             key_export_data)) {
-    QMessageBox::critical(nullptr, _("Error"),
-                          _("An error occur in exporting."));
+    QMessageBox::critical(this, _("Error"), _("An error occur in exporting."));
     return;
   }
 
   if (key_export_data->empty()) {
     QMessageBox::critical(
-        nullptr, _("Error"),
+        this, _("Error"),
         _("This key may not be able to export as OpenSSH format. Please check "
           "the key-size of the subkey(s) used to sign."));
     return;
@@ -492,7 +497,7 @@ void KeyMgmt::slotExportAsOpenSSHFormat() {
 
   key = GpgKeyGetter::GetInstance().GetKey(keys_checked->front());
   if (!key.good()) {
-    QMessageBox::critical(nullptr, _("Error"), _("Key Not Found."));
+    QMessageBox::critical(this, _("Error"), _("Key Not Found."));
     return;
   }
   QString fileString = QString::fromStdString(key.name() + " " + key.email() +
@@ -508,4 +513,59 @@ void KeyMgmt::slotExportAsOpenSSHFormat() {
   }
 }
 
+void KeyMgmt::slotImportKeyPackage() {
+  auto key_package_file_name = QFileDialog::getOpenFileName(
+      this, _("Import Key Package"), {},
+      QString(_("Key Package")) + " (*.gfepack);;All Files (*)");
+
+  if (key_package_file_name.isEmpty()) return;
+
+  auto encrypted_data =
+      read_all_data_in_file(key_package_file_name.toStdString());
+
+  if (encrypted_data.empty()) {
+    QMessageBox::critical(this, _("Error"),
+                          _("No data was read from the key package."));
+    return;
+  };
+
+  auto key_file_name = QFileDialog::getOpenFileName(
+      this, _("Import Key Package Passphrase File"), {},
+      QString(_("Key Package Passphrase File")) + " (*.key);;All Files (*)");
+
+  auto passphrase = read_all_data_in_file(key_file_name.toStdString());
+
+  LOG(INFO) << "passphrase size" << passphrase.size();
+  if (passphrase.size() != 256) {
+    QMessageBox::critical(
+        this, _("Wrong Passphrase"),
+        _("Please double check the passphrase you entered is correct."));
+    return;
+  }
+  auto hash_key = QCryptographicHash::hash(
+      QByteArray::fromStdString(passphrase), QCryptographicHash::Sha256);
+  auto encoded = QByteArray::fromStdString(encrypted_data);
+
+  QAESEncryption encryption(QAESEncryption::AES_256, QAESEncryption::ECB,
+                            QAESEncryption::Padding::ISO);
+
+  auto decoded = encryption.removePadding(encryption.decode(encoded, hash_key));
+  auto key_data = QByteArray::fromBase64(decoded);
+
+  if (!key_data.startsWith(GpgConstants::PGP_PUBLIC_KEY_BEGIN) &&
+      !key_data.startsWith(GpgConstants::PGP_PRIVATE_KEY_BEGIN)) {
+    QMessageBox::critical(
+        this, _("Wrong Passphrase"),
+        _("Please double check the passphrase you entered is correct."));
+    return;
+  }
+
+  auto key_data_ptr = std::make_unique<ByteArray>(key_data.toStdString());
+  auto info =
+      GpgKeyImportExporter::GetInstance().ImportKey(std::move(key_data_ptr));
+
+  auto dialog = new KeyImportDetailDialog(info, false, this);
+  dialog->exec();
+}
+
 }  // namespace GpgFrontend::UI