GpgFrontend/Modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: GpgFrontend:7238486de0c4f13f61626f0bccfc7502c45f9798
Branches Tags
GpgFrontend:main
..
compare: GpgFrontend:b70d73ce9610e415a751c0041368c3c759d12d85
Branches Tags
GpgFrontend:main

No commits in common. "7238486de0c4f13f61626f0bccfc7502c45f9798" and "b70d73ce9610e415a751c0041368c3c759d12d85" have entirely different histories.
7238486de0 ... b70d73ce96

4 changed files with 123 additions and 281 deletions
Show Stats Expand all files Collapse all files

35
include/GFModuleCommonUtils.hpp
View File

@ -94,23 +94,6 @@
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()); }
@ -138,22 +121,11 @@ 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...);
@ -163,13 +135,6 @@ 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...);

20
include/GFModuleDefine.h
View File

@ -44,23 +44,3 @@
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

134
src/m_email/EMailModule.cpp
View File

@ -43,144 +43,36 @@
#define VMIME_STATIC
#include <vmime/vmime.hpp>
// vmime extend
#include <vmime/contentTypeField.hpp>
#include "GFModuleCommonUtils.hpp"
#include "GFModuleDefine.h"
GF_MODULE_API_DEFINE_V2("com.bktus.gpgfrontend.module.email", "Email", "1.0.0",
"Everything related to E-Mails.", "Saturneric")
GF_MODULE_API_DEFINE("com.bktus.gpgfrontend.module.email", "Email", "1.0.0",
"Everything related to E-Mails.", "Saturneric")
DEFINE_TRANSLATIONS_STRUCTURE(ModuleEMail);
auto inline Q_SC(const std::string& s) -> QString {
return QString::fromStdString(s);
}
extern auto CalculateBinaryChacksum(const QString &path)
-> std::optional<QString>;
auto GFRegisterModule() -> int {
MLogDebug("email module registering...");
LISTEN("EMAIL_VERIFY_EML_DATA");
REGISTER_TRANS_READER();
vmime::datetime dl("Sat, 08 Oct 2005 14:07:52 +0200");
dl.getDay();
return 0;
}
auto GFActiveModule() -> int { return 0; }
REGISTER_EVENT_HANDLER(EMAIL_VERIFY_EML_DATA, [](const MEvent& event) -> int {
if (event["eml_data"].isEmpty()) CB_ERR(event, -1, "eml_data is empty");
EXECUTE_MODULE() {
FLOG_DEBUG("email executing, event id: %1", event["event_id"]);
auto data = QByteArray::fromBase64(QString(event["eml_data"]).toLatin1());
auto hash = QCryptographicHash::hash(data, QCryptographicHash::Sha1);
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;
});
CB_SUCC(event);
}
END_EXECUTE_MODULE()
auto GFDeactivateModule() -> int { return 0; }

215
src/m_key_server_sync/KeyServerSyncModule.cpp
View File

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