feat: support .eml file verifying

include/GFModuleCommonUtils.hpp

@@ -94,6 +94,23 @@
     return ret;                                                 \
   }
 
+#define DEFINE_EXECUTE_API_USING_STANDARD_EVEN_HANDLE_MODEL               \
+  EXECUTE_MODULE() {                                                      \
+    auto event_id = event["event_id"];                                    \
+    auto it = _gr_module_event_handlers.find(event_id);                   \
+    if (it != _gr_module_event_handlers.end()) {                          \
+      return it.value()(event);                                           \
+    }                                                                     \
+    CB_ERR(event, -1, QString("unsupported event id: %1").arg(event_id)); \
+  }                                                                       \
+  END_EXECUTE_MODULE()
+
+#define REGISTER_EVENT_HANDLER(event_id, handler)                      \
+  static const bool _gv_register_event_handler_by_id_##event_id = [] { \
+    _gr_module_event_handlers[#event_id] = handler;                    \
+    return true;                                                       \
+  }();
+
 inline void MLogDebug(const QString& s) { GFModuleLogDebug(s.toUtf8()); }
 inline void MLogInfo(const QString& s) { GFModuleLogInfo(s.toUtf8()); }
 inline void MLogWarn(const QString& s) { GFModuleLogWarn(s.toUtf8()); }
@@ -121,11 +138,22 @@ inline auto UnStrDup(const char* s) -> QString {
   return q_s;
 }
 
+inline auto FormatStringHelper(const QString& format,
+                               const std::string& arg) -> QString {
+  return format.arg(QString::fromStdString(arg));
+}
+
 template <typename T>
 auto FormatStringHelper(const QString& format, T arg) -> QString {
   return format.arg(arg);
 }
 
+template <typename... Args>
+auto FormatStringHelper(const QString& format, const std::string& arg,
+                        Args... args) -> QString {
+  return FormatStringHelper(format.arg(QString::fromStdString(arg)), args...);
+}
+
 template <typename T, typename... Args>
 auto FormatStringHelper(const QString& format, T arg, Args... args) -> QString {
   return FormatStringHelper(format.arg(arg), args...);
@@ -135,6 +163,13 @@ inline auto FormatStringHelper(const QString& format) -> QString {
   return format;
 }
 
+template <typename T>
+inline auto FormatStringHelper(const T& format) ->
+    typename std::enable_if<std::is_same<T, std::string>::value,
+                            QString>::type {
+  return FormatStringHelper(QString::fromStdString(format));
+}
+
 template <typename... Args>
 auto FormatString(const QString& format, Args... args) -> QString {
   return FormatStringHelper(format, args...);

include/GFModuleDefine.h

@@ -44,3 +44,23 @@
     return QMapToGFModuleMetaDataList(                                      \
         {{"Name", (name)}, {"Description", (desc)}, {"Author", (author)}}); \
   }
+
+#define GF_MODULE_API_DEFINE_V2(id, name, ver, desc, author)                \
+  auto GFGetModuleGFSDKVersion() -> const char* {                           \
+    return DUP(GF_SDK_VERSION_STR);                                         \
+  }                                                                         \
+  auto GFGetModuleQtEnvVersion() -> const char* {                           \
+    return DUP(QT_VERSION_STR);                                             \
+  }                                                                         \
+  auto GFGetModuleID() -> const char* { return DUP((id)); }                 \
+  auto GFGetModuleVersion() -> const char* { return DUP((ver)); }           \
+  auto GFGetModuleMetaData() -> GFModuleMetaData* {                         \
+    return QMapToGFModuleMetaDataList(                                      \
+        {{"Name", (name)}, {"Description", (desc)}, {"Author", (author)}}); \
+  }                                                                         \
+  using MEvent = QMap<QString, QString>;                                    \
+  using EventHandler = std::function<int(const MEvent&)>;                   \
+  static QMap<QString, EventHandler> Module##nameEventHandlers;             \
+  static QMap<QString, EventHandler>& _gr_module_event_handlers =           \
+      Module##nameEventHandlers;                                            \
+  DEFINE_EXECUTE_API_USING_STANDARD_EVEN_HANDLE_MODEL

src/m_email/EMailModule.cpp

@@ -43,36 +43,144 @@
 #define VMIME_STATIC
 #include <vmime/vmime.hpp>
 
+// vmime extend
+#include <vmime/contentTypeField.hpp>
+
 #include "GFModuleCommonUtils.hpp"
 #include "GFModuleDefine.h"
 
-GF_MODULE_API_DEFINE("com.bktus.gpgfrontend.module.email", "Email", "1.0.0",
+GF_MODULE_API_DEFINE_V2("com.bktus.gpgfrontend.module.email", "Email", "1.0.0",
-                     "Everything related to E-Mails.", "Saturneric")
+                        "Everything related to E-Mails.", "Saturneric")
 
 DEFINE_TRANSLATIONS_STRUCTURE(ModuleEMail);
 
-extern auto CalculateBinaryChacksum(const QString &path)
+auto inline Q_SC(const std::string& s) -> QString {
-    -> std::optional<QString>;
+  return QString::fromStdString(s);
+}
 
 auto GFRegisterModule() -> int {
   MLogDebug("email module registering...");
 
-  REGISTER_TRANS_READER();
+  LISTEN("EMAIL_VERIFY_EML_DATA");
-
-  vmime::datetime dl("Sat, 08 Oct 2005 14:07:52 +0200");
-  dl.getDay();
 
   return 0;
 }
 
 auto GFActiveModule() -> int { return 0; }
 
-EXECUTE_MODULE() {
+REGISTER_EVENT_HANDLER(EMAIL_VERIFY_EML_DATA, [](const MEvent& event) -> int {
-  FLOG_DEBUG("email executing, event id: %1", event["event_id"]);
+  if (event["eml_data"].isEmpty()) CB_ERR(event, -1, "eml_data is empty");
 
-  CB_SUCC(event);
+  auto data = QByteArray::fromBase64(QString(event["eml_data"]).toLatin1());
-}
+  auto hash = QCryptographicHash::hash(data, QCryptographicHash::Sha1);
-END_EXECUTE_MODULE()
+  FLOG_DEBUG("E-Mail Raw Data SHA-1 Hash: %1", hash.toHex());
+
+  vmime::string vmime_data(data.constData(), data.size());
+
+  auto message = vmime::make_shared<vmime::message>();
+  try {
+    message->parse(vmime_data);
+  } catch (const vmime::exception& e) {
+    FLOG_DEBUG("error when parsing vmime data: %1", e.what());
+    CB_ERR(event, -2, "error when parsing vmime data");
+  }
+
+  auto header = message->getHeader();
+
+  auto content_type_field =
+      header->getField<vmime::contentTypeField>(vmime::fields::CONTENT_TYPE);
+
+  auto content_type_value =
+      Q_SC(content_type_field->getValue()->generate()).trimmed();
+
+  /*
+   * OpenPGP signed messages are denoted by the "multipart/signed" content type.
+   */
+  if (content_type_value != "multipart/signed")
+    CB_ERR(event, -2, "Content-Type must be multipart/signed");
+
+  auto prm_protocol = content_type_field->getParameter("protocol");
+  auto prm_protocol_value = Q_SC(prm_protocol->getValue().generate());
+
+  /*
+   * with a "protocol" parameter which MUST have a value of
+   * "application/pgp-signature"
+   */
+  if (prm_protocol_value != "application/pgp-signature")
+    CB_ERR(event, -2,
+           "protocol of Content-Type MUST be application/pgp-signature");
+
+  auto body = message->getBody();
+  auto content_type = body->getContentType();
+  auto part_count = body->getPartCount();
+
+  FLOG_DEBUG("body content type: %1", content_type.generate());
+  FLOG_DEBUG("body page count: %1", part_count);
+
+  /*
+   * The multipart/signed body MUST consist of exactly two parts.
+   */
+  if (part_count != 2)
+    CB_ERR(event, -2, "body MUST consist of exactly two parts");
+
+  /*
+    The first part contains the signed data in MIME canonical format,
+    including a set of appropriate content headers describing the data.
+  */
+  auto part_mime = body->getPartAt(0);
+  auto part_mime_parse_offset = part_mime->getParsedOffset();
+  auto part_mime_parse_length = part_mime->getParsedLength();
+
+  auto part_mime_content_text = QByteArray::fromStdString(
+      vmime_data.substr(part_mime_parse_offset, part_mime_parse_length));
+
+  FLOG_DEBUG("body part of raw offset: %1, length: %2", part_mime_parse_offset,
+             part_mime_parse_length);
+  FLOG_DEBUG("body part of raw content left: %1",
+             part_mime_content_text.left(64));
+  FLOG_DEBUG("body part of raw content right: %1",
+             part_mime_content_text.right(64));
+
+  auto part_mime_content_hash = QCryptographicHash::hash(
+      part_mime_content_text, QCryptographicHash::Sha1);
+  FLOG_DEBUG("body part of raw content hash: %1",
+             part_mime_content_hash.toHex());
+
+  if (part_mime_content_text.isEmpty())
+    CB_ERR(event, -2, "mime raw data part is empty");
+
+  /*
+   * The second body MUST contain the OpenPGP digital signature.  It MUST
+   * be labeled with a content type of "application/pgp-signature"
+   */
+  auto part_sign = body->getPartAt(1);
+  auto part_sign_header = part_sign->getHeader();
+  auto part_sign_content_type = part_sign_header->ContentType();
+  auto part_sign_content_type_value =
+      Q_SC(part_sign_content_type->getValue()->generate());
+
+  if (part_sign_content_type_value != "application/pgp-signature")
+    CB_ERR(
+        event, -2,
+        "signature part must have a Content-Type of application/pgp-signature");
+
+  auto part_sign_body_content =
+      QByteArray::fromStdString(part_sign->getBody()->generate());
+  if (part_sign_body_content.trimmed().isEmpty())
+    CB_ERR(event, -2, "signature part is empty");
+
+  FLOG_DEBUG("body part of signature content: %1", part_sign_body_content);
+
+  // callback
+  CB(event, GFGetModuleID(),
+     {
+         {"ret", QString::number(0)},
+         {"mime", QString::fromLatin1(part_mime_content_text.toBase64())},
+         {"signature", QString::fromLatin1(part_sign_body_content.toBase64())},
+     });
+
+  return 0;
+});
 
 auto GFDeactivateModule() -> int { return 0; }
 

src/m_key_server_sync/KeyServerSyncModule.cpp

@@ -30,13 +30,13 @@
 
 #include <QtCore>
 
-#include "GFModuleCommonUtils.hpp"
 #include "GFModuleDefine.h"
 #include "VKSInterface.h"
 
-GF_MODULE_API_DEFINE("com.bktus.gpgfrontend.module.key_server_sync",
+GF_MODULE_API_DEFINE_V2("com.bktus.gpgfrontend.module.key_server_sync",
-                     "KeyServerSync", "1.0.0",
+                        "KeyServerSync", "1.0.0",
-                     "Sync Information From Trusted Key Server.", "Saturneric")
+                        "Sync Information From Trusted Key Server.",
+                        "Saturneric")
 
 auto GFRegisterModule() -> int {
   LOG_DEBUG("key server sync module registering");
@@ -51,122 +51,117 @@ auto GFActiveModule() -> int {
   return 0;
 }
 
-EXECUTE_MODULE() {
+REGISTER_EVENT_HANDLER(
-  FLOG_DEBUG("key server sync module executing, event id: %1",
+    REQUEST_GET_PUBLIC_KEY_BY_FINGERPRINT, [](const MEvent& event) -> int {
-             event["event_id"]);
+      if (event["fingerprint"].isEmpty())
+        CB_ERR(event, -1, "fingerprint is empty");
 
-  if (event["event_id"] == "REQUEST_GET_PUBLIC_KEY_BY_FINGERPRINT") {
+      QByteArray fingerprint = event["fingerprint"].toLatin1();
-    if (event["fingerprint"].isEmpty())
+      FLOG_DEBUG("try to get key info of fingerprint: %1", fingerprint);
-      CB_ERR(event, -1, "fingerprint is empty");
 
-    QByteArray fingerprint = event["fingerprint"].toLatin1();
+      auto* vks = new VKSInterface();
-    FLOG_DEBUG("try to get key info of fingerprint: %1", fingerprint);
+      QObject::connect(vks, &VKSInterface::SignalKeyRetrieved,
+                       QThread::currentThread(), [event](const QString& key) {
+                         // callback
+                         CB(event, GFGetModuleID(),
+                            {
+                                {"ret", QString::number(0)},
+                                {"key_data", key},
+                            });
+                       });
+      QObject::connect(vks, &VKSInterface::SignalKeyRetrieved, vks,
+                       &VKSInterface::deleteLater);
 
-    auto* vks = new VKSInterface();
+      QObject::connect(vks, &VKSInterface::SignalErrorOccurred,
-    QObject::connect(vks, &VKSInterface::SignalKeyRetrieved,
+                       QThread::currentThread(),
-                     QThread::currentThread(), [event](const QString& key) {
+                       [event](const QString& error, const QString& data) {
-                       // callback
+                         CB(event, GFGetModuleID(),
-                       CB(event, GFGetModuleID(),
+                            {
-                          {
+                                {"ret", QString::number(-1)},
-                              {"ret", QString::number(0)},
+                                {"error_msg", error},
-                              {"key_data", key},
+                                {"reply_data", data},
-                          });
+                            });
-                     });
+                       });
-    QObject::connect(vks, &VKSInterface::SignalKeyRetrieved, vks,
+      QObject::connect(vks, &VKSInterface::SignalKeyRetrieved, vks,
-                     &VKSInterface::deleteLater);
+                       &VKSInterface::deleteLater);
+      vks->GetByFingerprint(fingerprint);
+      return 0;
+    });
 
-    QObject::connect(vks, &VKSInterface::SignalErrorOccurred,
+REGISTER_EVENT_HANDLER(
-                     QThread::currentThread(),
+    REQUEST_GET_PUBLIC_KEY_BY_KEY_ID, [](const MEvent& event) -> int {
-                     [event](const QString& error, const QString& data) {
+      if (event["key_id"].isEmpty()) CB_ERR(event, -1, "key_id is empty");
-                       CB(event, GFGetModuleID(),
-                          {
-                              {"ret", QString::number(-1)},
-                              {"error_msg", error},
-                              {"reply_data", data},
-                          });
-                     });
-    QObject::connect(vks, &VKSInterface::SignalKeyRetrieved, vks,
-                     &VKSInterface::deleteLater);
-    vks->GetByFingerprint(fingerprint);
 
-    return 0;
+      QByteArray key_id = event["key_id"].toLatin1();
-  }
+      FLOG_DEBUG("try to get key info of key id: %1", key_id);
 
-  if (event["event_id"] == "REQUEST_GET_PUBLIC_KEY_BY_KEY_ID") {
+      auto* vks = new VKSInterface();
-    if (event["key_id"].isEmpty()) CB_ERR(event, -1, "key_id is empty");
+      QObject::connect(vks, &VKSInterface::SignalKeyRetrieved,
+                       QThread::currentThread(), [event](const QString& key) {
+                         // callback
+                         CB(event, GFGetModuleID(),
+                            {
+                                {"ret", QString::number(0)},
+                                {"key_data", key},
+                            });
+                       });
+      QObject::connect(vks, &VKSInterface::SignalKeyRetrieved, vks,
+                       &VKSInterface::deleteLater);
+      QObject::connect(vks, &VKSInterface::SignalErrorOccurred,
+                       QThread::currentThread(),
+                       [event](const QString& error, const QString& data) {
+                         CB(event, GFGetModuleID(),
+                            {
+                                {"ret", QString::number(-1)},
+                                {"error_msg", error},
+                                {"reply_data", data},
+                            });
+                       });
+      QObject::connect(vks, &VKSInterface::SignalKeyRetrieved, vks,
+                       &VKSInterface::deleteLater);
+      vks->GetByKeyId(key_id);
 
-    QByteArray key_id = event["key_id"].toLatin1();
+      return 0;
-    FLOG_DEBUG("try to get key info of key id: %1", key_id);
+    });
 
-    auto* vks = new VKSInterface();
+REGISTER_EVENT_HANDLER(
-    QObject::connect(vks, &VKSInterface::SignalKeyRetrieved,
+    REQUEST_UPLOAD_PUBLIC_KEY, [](const MEvent& event) -> int {
-                     QThread::currentThread(), [event](const QString& key) {
+      if (event["key_text"].isEmpty()) CB_ERR(event, -1, "key_text is empty");
-                       // callback
-                       CB(event, GFGetModuleID(),
-                          {
-                              {"ret", QString::number(0)},
-                              {"key_data", key},
-                          });
-                     });
-    QObject::connect(vks, &VKSInterface::SignalKeyRetrieved, vks,
-                     &VKSInterface::deleteLater);
-    QObject::connect(vks, &VKSInterface::SignalErrorOccurred,
-                     QThread::currentThread(),
-                     [event](const QString& error, const QString& data) {
-                       CB(event, GFGetModuleID(),
-                          {
-                              {"ret", QString::number(-1)},
-                              {"error_msg", error},
-                              {"reply_data", data},
-                          });
-                     });
-    QObject::connect(vks, &VKSInterface::SignalKeyRetrieved, vks,
-                     &VKSInterface::deleteLater);
-    vks->GetByKeyId(key_id);
 
-    return 0;
+      QByteArray key_text = event["key_text"].toLatin1();
-  }
+      FLOG_DEBUG("try to get key info of key id: %1", key_text);
 
-  if (event["event_id"] == "REQUEST_UPLOAD_PUBLIC_KEY") {
+      auto* vks = new VKSInterface();
-    if (event["key_text"].isEmpty()) CB_ERR(event, -1, "key_text is empty");
+      QObject::connect(
-
+          vks, &VKSInterface::SignalKeyUploaded, QThread::currentThread(),
-    QByteArray key_text = event["key_text"].toLatin1();
+          [event](const QString& fpr, const QJsonObject& status,
-    FLOG_DEBUG("try to get key info of key id: %1", key_text);
+                  const QString& token) {
-
+            CB(event, GFGetModuleID(),
-    auto* vks = new VKSInterface();
+               {
-    QObject::connect(
+                   {"ret", QString::number(0)},
-        vks, &VKSInterface::SignalKeyUploaded, QThread::currentThread(),
+                   {"fingerprint", fpr},
-        [event](const QString& fpr, const QJsonObject& status,
+                   {"status",
-                const QString& token) {
+                    QString::fromUtf8(QJsonDocument(status).toJson())},
-          CB(event, GFGetModuleID(),
+                   {"token", token},
-             {
+               });
-                 {"ret", QString::number(0)},
+          });
-                 {"fingerprint", fpr},
+      QObject::connect(vks, &VKSInterface::SignalKeyRetrieved, vks,
-                 {"status", QString::fromUtf8(QJsonDocument(status).toJson())},
+                       &VKSInterface::deleteLater);
-                 {"token", token},
+      QObject::connect(vks, &VKSInterface::SignalErrorOccurred,
-             });
+                       QThread::currentThread(),
-        });
+                       [event](const QString& error, const QString& data) {
-    QObject::connect(vks, &VKSInterface::SignalKeyRetrieved, vks,
+                         CB(event, GFGetModuleID(),
-                     &VKSInterface::deleteLater);
+                            {
-    QObject::connect(vks, &VKSInterface::SignalErrorOccurred,
+                                {"ret", QString::number(-1)},
-                     QThread::currentThread(),
+                                {"error_msg", error},
-                     [event](const QString& error, const QString& data) {
+                                {"reply_data", data},
-                       CB(event, GFGetModuleID(),
+                            });
-                          {
+                       });
-                              {"ret", QString::number(-1)},
+      QObject::connect(vks, &VKSInterface::SignalKeyRetrieved, vks,
-                              {"error_msg", error},
+                       &VKSInterface::deleteLater);
-                              {"reply_data", data},
+      vks->UploadKey(key_text);
-                          });
+      return 0;
-                     });
+    });
-    QObject::connect(vks, &VKSInterface::SignalKeyRetrieved, vks,
-                     &VKSInterface::deleteLater);
-    vks->UploadKey(key_text);
-    return 0;
-  }
-
-  CB_ERR(event, -1, "the type of this event is not supported");
-}
-END_EXECUTE_MODULE()
 
 auto GFDeactivateModule() -> int { return 0; }