path: root/src/m_email/EMailModule.cpp

/**
 * Copyright (C) 2021-2024 Saturneric <[email protected]>
 *
 * This file is part of GpgFrontend.
 *
 * GpgFrontend is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GpgFrontend is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with GpgFrontend. If not, see <https://www.gnu.org/licenses/>.
 *
 * The initial version of the source code is inherited from
 * the gpg4usb project, which is under GPL-3.0-or-later.
 *
 * All the source code of GpgFrontend was modified and released by
 * Saturneric <[email protected]> starting on May 12, 2021.
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 *
 */

#include "EMailModule.h"

#include <GFSDKBasic.h>
#include <GFSDKBuildInfo.h>
#include <GFSDKLog.h>

// qt
#include <QCoreApplication>
#include <QCryptographicHash>
#include <QFileInfo>
#include <QJsonDocument>
#include <QString>

#include "EMailMetaDataDialog.h"

// vmime
#define VMIME_STATIC
#include <vmime/vmime.hpp>

// vmime extend
#include <vmime/contentTypeField.hpp>

#include "GFModuleCommonUtils.hpp"
#include "GFModuleDefine.h"

//
#include "EMailBasicGpgOpera.h"
#include "EMailHelper.h"
#include "EMailMetaDataDialog.h"

GF_MODULE_API_DEFINE_V2("com.bktus.gpgfrontend.module.email", "Email", "1.0.0",
                        "Everything related to E-Mails.", "Saturneric")

DEFINE_TRANSLATIONS_STRUCTURE(ModuleEMail);

auto GFRegisterModule() -> int {
  MLogDebug("email module registering...");

  LISTEN("EMAIL_VERIFY_EML_DATA");
  LISTEN("EMAIL_DECRYPT_EML_DATA");
  LISTEN("EMAIL_SIGN_EML_DATA");
  LISTEN("EMAIL_ENCRYPT_EML_DATA");
  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");

  auto data = QByteArray::fromBase64(QString(event["eml_data"]).toLatin1());
  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 eml raw data");
  }

  auto header = message->getHeader();

  auto content_type_field =
      header->getField<vmime::contentTypeField>(vmime::fields::CONTENT_TYPE);
  if (!content_type_field) {
    CB_ERR(event, -2, "Cannot get 'Content-Type' Field from header");
  }

  auto content_type_value =
      Q_SC(content_type_field->getValue()->generate()).trimmed();

  auto prm_protocol = content_type_field->getParameter("protocol");
  if (!prm_protocol) {
    CB_ERR(event, -2, "Cannot get 'protocol' from 'Content-Type'");
  }

  /*
   * OpenPGP signed messages are denoted by the "multipart/signed" content
   * type.
   */
  if (content_type_value != "multipart/signed")
    CB_ERR(event, -2,
           "OpenPGP signed messages are denoted by the 'multipart/signed' "
           "content type");

  /*
   * with a "protocol" parameter which MUST have a value of
   * "application/pgp-signature"
   */
  auto prm_protocol_value = Q_SC(prm_protocol->getValue().generate());
  if (prm_protocol_value != "application/pgp-signature")
    CB_ERR(event, -2,
           "The 'protocol' parameter which MUST have a value of "
           "'application/pgp-signature' (MUST be quoted)");

  auto prm_micalg = content_type_field->getParameter("micalg");
  if (!prm_micalg) {
    CB_ERR(event, -2, "cannot get 'micalg' from 'Content-Type'");
  }

  /*
   * The "micalg" parameter for the "application/pgp-signature" protocol
   * MUST contain exactly one hash-symbol of the format "pgp-<hash-
   * identifier>", where <hash-identifier> identifies the Message
   * Integrity Check (MIC) algorithm used to generate the signature.
   */
  auto prm_micalg_value = Q_SC(prm_micalg->getValue().generate());
  FLOG_DEBUG("micalg value: %1", prm_micalg_value);
  if (!IsValidMicalgFormat(prm_micalg_value)) {
    CB_ERR(event, -2,
           "The 'micalg' parameter MUST contain exactly one hash-symbol of the "
           "format 'pgp-<hash-identifier>'");
  }

  auto from_field_value_text =
      ExtractFieldValueMailBox(header, vmime::fields::FROM);
  auto to_field_value_text =
      ExtractFieldValueAddressList(header, vmime::fields::TO);
  auto cc_field_value_text =
      ExtractFieldValueAddressList(header, vmime::fields::CC);
  auto bcc_field_value_text =
      ExtractFieldValueAddressList(header, vmime::fields::BCC);
  auto date_field_value =
      ExtractFieldValueDateTime(header, vmime::fields::DATE);
  auto subject_field_value_text =
      ExtractFieldValueText(header, vmime::fields::SUBJECT);
  auto reply_to_field_value_text =
      ExtractFieldValueMailBox(header, vmime::fields::REPLY_TO);
  auto organization_text =
      ExtractFieldValueText(header, vmime::fields::ORGANIZATION);

  auto body = message->getBody();
  auto content_type = body->getContentType();
  auto part_count = body->getPartCount();

  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,
           "The multipart/signed 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("mime part info, raw offset: %1, length: %2",
             part_mime_parse_offset, part_mime_parse_length);

  auto part_mime_content_hash = QCryptographicHash::hash(
      part_mime_content_text, QCryptographicHash::Sha1);
  FLOG_DEBUG("mime part of raw content hash: %1",
             part_mime_content_hash.toHex());

  FLOG_DEBUG("mime part of raw content: %1", part_mime_content_text);
  qDebug().noquote() << "\n" << part_mime_content_text;

  if (part_mime_content_text.isEmpty())
    CB_ERR(event, -2, "mime raw data part is empty");

  auto attachments =
      vmime::attachmentHelper::findAttachmentsInBodyPart(part_mime);
  FLOG_DEBUG("mime part info, attachment count: %1", attachments.size());

  QStringList public_keys_buffer;

  for (const auto& att : attachments) {
    auto att_type = Q_SC(att->getType().generate()).trimmed();
    FLOG_DEBUG("mime part info, attachment type: %1", att_type);

    if (att_type != "application/pgp-keys") continue;

    std::ostringstream oss;
    vmime::utility::outputStreamAdapter osa(oss);
    att->getData()->extract(osa);

    public_keys_buffer.append(Q_SC(oss.str()));
  }

  FLOG_DEBUG("mime part info, attached public keys: ",
             public_keys_buffer.join("\n"));

  /*
   * 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,
           "The second body MUST be labeled with 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, "The 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())},
         {"mime_hash", part_mime_content_hash.toHex()},
         {"signature", QString::fromLatin1(part_sign_body_content.toBase64())},
         {"from", from_field_value_text},
         {"to", to_field_value_text},
         {"cc", cc_field_value_text},
         {"bcc", bcc_field_value_text},
         {"subject", subject_field_value_text},
         {"datetime", QString::number(date_field_value.toMSecsSinceEpoch())},
         {"micalg", prm_micalg_value},
         {"public_keys", public_keys_buffer.join("\n")},
     });

  return 0;
});

REGISTER_EVENT_HANDLER(EMAIL_DECRYPT_EML_DATA, [](const MEvent& event) -> int {
  if (event["eml_data"].isEmpty()) CB_ERR(event, -1, "eml_data is empty");

  auto data = QByteArray::fromBase64(QString(event["eml_data"]).toLatin1());
  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);
  if (!content_type_field) {
    CB_ERR(event, -2, "cannot get 'Content-Type' Field from header");
  }

  auto content_type_value =
      Q_SC(content_type_field->getValue()->generate()).trimmed();

  auto prm_protocol = content_type_field->getParameter("protocol");
  if (!prm_protocol) {
    CB_ERR(event, -2, "cannot get 'protocol' from 'Content-Type'");
  }

  /*
   * OpenPGP encrypted data is denoted by the "multipart/encrypted"
   * content type
   */
  if (content_type_value != "multipart/encrypted")
    CB_ERR(event, -2,
           "OpenPGP encrypted data is denoted by the 'multipart/encrypted' "
           "content type");

  /*
   * MUST have a "protocol" parameter value of "application/pgp-encrypted"
   */
  auto prm_protocol_value = Q_SC(prm_protocol->getValue().generate());
  if (prm_protocol_value != "application/pgp-encrypted")
    CB_ERR(event, -2,
           "'protocol' parameter which MUST have a value of "
           "'application/pgp-encrypted' (MUST be quoted)");

  auto from_field_value_text =
      ExtractFieldValueMailBox(header, vmime::fields::FROM);
  auto to_field_value_text =
      ExtractFieldValueAddressList(header, vmime::fields::TO);
  auto cc_field_value_text =
      ExtractFieldValueAddressList(header, vmime::fields::CC);
  auto bcc_field_value_text =
      ExtractFieldValueAddressList(header, vmime::fields::BCC);
  auto date_field_value =
      ExtractFieldValueDateTime(header, vmime::fields::DATE);
  auto subject_field_value_text =
      ExtractFieldValueText(header, vmime::fields::SUBJECT);
  auto reply_to_field_value_text =
      ExtractFieldValueMailBox(header, vmime::fields::REPLY_TO);
  auto organization_text =
      ExtractFieldValueText(header, vmime::fields::ORGANIZATION);

  auto body = message->getBody();
  auto content_type = body->getContentType();
  auto part_count = body->getPartCount();

  FLOG_DEBUG("body page count: %1", part_count);

  /*
   * The multipart/encrypted body MUST consist of exactly two parts.
   */
  if (part_count != 2)
    CB_ERR(event, -2,
           "The multipart/signed body MUST consist of exactly two parts");

  /*
   * The multipart/encrypted MIME body MUST consist of exactly two body
   * parts, the first with content type "application/pgp-encrypted".  This
   * body contains the control information.
   */
  auto part_mime = body->getPartAt(0);

  std::ostringstream oss;
  vmime::utility::outputStreamAdapter osa(oss);

  auto part_mime_body = part_mime->getBody();
  auto part_mime_body_content = part_mime_body->getContents();
  if (!part_mime_body_content) {
    CB_ERR(event, -2, "Cannot get the content of the first part's body");
  }

  part_mime_body_content->extractRaw(osa);
  osa.flush();

  auto part_mime_body_content_text = Q_SC(oss.str());
  FLOG_DEBUG("body part of raw content text: %1", part_mime_body_content_text);

  /*
   * A message complying with this
   * standard MUST contain a "Version: 1" field in this body.
   */
  if (!part_mime_body_content_text.contains("Version: 1")) {
    CB_ERR(event, -2,
           "The first part MUST contain a 'Version: 1' field in this body.");
  }

  /*
   * The second MIME body part MUST contain the actual encrypted data.  It
   * MUST be labeled with a content type of "application/octet-stream".
   */
  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/octet-stream")
    CB_ERR(event, -2,
           "The second part MUST be labeled with a content type of "
           "'application/octet-stream'");

  auto part_encr_body_content =
      QByteArray::fromStdString(part_sign->getBody()->generate());
  if (part_encr_body_content.trimmed().isEmpty())
    CB_ERR(event, -2, "The second part is empty");

  FLOG_DEBUG("body part of encrypt content: %1", part_encr_body_content);

  // callback
  CB(event, GFGetModuleID(),
     {
         {"ret", QString::number(0)},
         {"encrypted", QString::fromLatin1(part_encr_body_content.toBase64())},
         {"from", from_field_value_text},
         {"to", to_field_value_text},
         {"cc", cc_field_value_text},
         {"bcc", bcc_field_value_text},
         {"subject", subject_field_value_text},
         {"datetime", QString::number(date_field_value.toMSecsSinceEpoch())},
     });

  return 0;
});

REGISTER_EVENT_HANDLER(EMAIL_SIGN_EML_DATA, [](const MEvent& event) -> int {
  if (event["body_data"].isEmpty()) CB_ERR(event, -1, "body_data is empty");
  if (event["channel"].isEmpty()) CB_ERR(event, -1, "channel is empty");
  if (event["sign_key"].isEmpty()) CB_ERR(event, -1, "sign_key is empty");

  auto channel = event.value("channel", "0").toInt();
  auto sign_key = event.value("sign_key", "");

  FLOG_DEBUG("eml sign key: %1", sign_key);

  auto body_data =
      QByteArray::fromBase64(QString(event["body_data"]).toLatin1());

  auto* dialog = GUI_OBJECT(CreateEMailMetaDataDialog, 0);
  auto* r_dialog =
      qobject_cast<EMailMetaDataDialog*>(static_cast<QObject*>(dialog));
  if (r_dialog == nullptr)
    CB_ERR(event, -1, "convert dialog to r_dialog failed");

  r_dialog->SetChannel(channel);
  r_dialog->SetKeys({sign_key});
  r_dialog->SetBodyData({body_data});

  GFUIShowDialog(dialog, nullptr);
  QObject::connect(r_dialog, &EMailMetaDataDialog::SignalEMLMetaData, r_dialog,
                   [=](const EMailMetaData& meta_data) {
                     QString eml_data;
                     auto ret = SignEMLData(channel, sign_key, meta_data,
                                            body_data, eml_data);
                     if (ret != 0) {
                       CB_ERR(event, -2, eml_data);
                     }

                     CB(event, GFGetModuleID(),
                        {
                            {"ret", QString::number(0)},
                            {"eml_data", eml_data},
                        });
                     return 0;
                   });

  QObject::connect(
      r_dialog, &EMailMetaDataDialog::SignalNoEMLMetaData, r_dialog,
      [=](const QString& error_string) { CB_ERR(event, -1, error_string); });

  return 0;
});

REGISTER_EVENT_HANDLER(EMAIL_ENCRYPT_EML_DATA, [](const MEvent& event) -> int {
  if (event["body_data"].isEmpty()) CB_ERR(event, -1, "body_data is empty");
  if (event["channel"].isEmpty()) CB_ERR(event, -1, "channel is empty");
  if (event["encrypt_keys"].isEmpty())
    CB_ERR(event, -1, "encrypt_keys is empty");

  auto channel = event.value("channel", "0").toInt();
  auto encrypt_keys = event.value("encrypt_keys", "").split(';');

  FLOG_DEBUG("eml encrypt keys: %1", encrypt_keys.join(';'));

  auto body_data =
      QByteArray::fromBase64(QString(event["body_data"]).toLatin1());

  auto* dialog = GUI_OBJECT(CreateEMailMetaDataDialog, 1);
  auto* r_dialog =
      qobject_cast<EMailMetaDataDialog*>(static_cast<QObject*>(dialog));
  if (r_dialog == nullptr)
    CB_ERR(event, -1, "convert dialog to r_dialog failed");

  r_dialog->SetChannel(channel);
  r_dialog->SetKeys(encrypt_keys);
  r_dialog->SetBodyData({body_data});

  GFUIShowDialog(dialog, nullptr);

  QObject::connect(r_dialog, &EMailMetaDataDialog::SignalEMLMetaData, r_dialog,
                   [=](const EMailMetaData& meta_data) {
                     QString eml_data;
                     auto ret = EncryptEMLData(channel, encrypt_keys, meta_data,
                                               body_data, eml_data);
                     if (ret != 0) {
                       CB_ERR(event, -2, eml_data);
                     }

                     CB(event, GFGetModuleID(),
                        {
                            {"ret", QString::number(0)},
                            {"eml_data", eml_data},
                        });
                     return 0;
                   });

  QObject::connect(
      r_dialog, &EMailMetaDataDialog::SignalNoEMLMetaData, r_dialog,
      [=](const QString& error_string) { CB_ERR(event, -1, error_string); });

  return 0;
});

auto GFDeactivateModule() -> int { return 0; }

auto GFUnregisterModule() -> int {
  MLogDebug("email module unregistering...");

  return 0;
}