2012-07-17 18:15:47 +02:00
|
|
|
/*
|
2022-02-22 21:48:29 +01:00
|
|
|
** Copyright (C) 2012-2022 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
|
2012-07-17 18:15:47 +02:00
|
|
|
**
|
|
|
|
** This program 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, or (at your option) any
|
|
|
|
** later version.
|
|
|
|
**
|
|
|
|
** This program 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 this program; if not, write to the Free Software Foundation,
|
|
|
|
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
**
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
|
2012-07-22 18:39:17 +02:00
|
|
|
#include <string.h>
|
2022-02-22 21:48:29 +01:00
|
|
|
#include <utils/mu-utils.hh>
|
2012-07-22 18:39:17 +02:00
|
|
|
|
2022-02-22 21:48:29 +01:00
|
|
|
#include "gmime/gmime-signature.h"
|
2020-11-28 09:15:49 +01:00
|
|
|
#include "mu-msg.hh"
|
|
|
|
#include "mu-msg-priv.hh"
|
|
|
|
#include "mu-msg-part.hh"
|
2012-07-17 18:15:47 +02:00
|
|
|
|
|
|
|
#include <gmime/gmime.h>
|
|
|
|
#include <gmime/gmime-multipart-signed.h>
|
|
|
|
|
2020-11-28 09:15:49 +01:00
|
|
|
using namespace Mu;
|
2012-07-17 18:15:47 +02:00
|
|
|
|
2012-08-30 19:26:35 +02:00
|
|
|
static const char*
|
2021-10-20 11:18:15 +02:00
|
|
|
get_pubkey_algo_name(GMimePubKeyAlgo algo)
|
2012-08-30 19:26:35 +02:00
|
|
|
{
|
2020-11-28 09:15:49 +01:00
|
|
|
#pragma GCC diagnostic push
|
2021-10-20 11:18:15 +02:00
|
|
|
#pragma GCC diagnostic ignored "-Wswitch-enum"
|
2012-08-30 19:26:35 +02:00
|
|
|
switch (algo) {
|
2021-10-20 11:18:15 +02:00
|
|
|
case GMIME_PUBKEY_ALGO_DEFAULT: return "default";
|
|
|
|
case GMIME_PUBKEY_ALGO_RSA: return "RSA";
|
|
|
|
case GMIME_PUBKEY_ALGO_RSA_E: return "RSA (encryption only)";
|
|
|
|
case GMIME_PUBKEY_ALGO_RSA_S: return "RSA (signing only)";
|
|
|
|
case GMIME_PUBKEY_ALGO_ELG_E: return "ElGamal (encryption only)";
|
|
|
|
case GMIME_PUBKEY_ALGO_DSA: return "DSA";
|
|
|
|
case GMIME_PUBKEY_ALGO_ELG: return "ElGamal";
|
|
|
|
default: return "unknown pubkey algorithm";
|
2012-08-30 19:26:35 +02:00
|
|
|
}
|
2020-11-28 09:15:49 +01:00
|
|
|
#pragma GCC diagnostic pop
|
2012-08-30 19:26:35 +02:00
|
|
|
}
|
2012-07-18 09:30:23 +02:00
|
|
|
|
2012-08-30 19:26:35 +02:00
|
|
|
static const gchar*
|
2021-10-20 11:18:15 +02:00
|
|
|
get_digestkey_algo_name(GMimeDigestAlgo algo)
|
2012-08-30 19:26:35 +02:00
|
|
|
{
|
2020-11-28 09:15:49 +01:00
|
|
|
#pragma GCC diagnostic push
|
2021-10-20 11:18:15 +02:00
|
|
|
#pragma GCC diagnostic ignored "-Wswitch-enum"
|
2012-08-30 19:26:35 +02:00
|
|
|
switch (algo) {
|
2021-10-20 11:18:15 +02:00
|
|
|
case GMIME_DIGEST_ALGO_DEFAULT: return "default";
|
|
|
|
case GMIME_DIGEST_ALGO_MD5: return "MD5";
|
|
|
|
case GMIME_DIGEST_ALGO_SHA1: return "SHA-1";
|
|
|
|
case GMIME_DIGEST_ALGO_RIPEMD160: return "RIPEMD160";
|
|
|
|
case GMIME_DIGEST_ALGO_MD2: return "MD2";
|
|
|
|
case GMIME_DIGEST_ALGO_TIGER192: return "TIGER-192";
|
|
|
|
case GMIME_DIGEST_ALGO_HAVAL5160: return "HAVAL-5-160";
|
|
|
|
case GMIME_DIGEST_ALGO_SHA256: return "SHA-256";
|
|
|
|
case GMIME_DIGEST_ALGO_SHA384: return "SHA-384";
|
|
|
|
case GMIME_DIGEST_ALGO_SHA512: return "SHA-512";
|
|
|
|
case GMIME_DIGEST_ALGO_SHA224: return "SHA-224";
|
|
|
|
case GMIME_DIGEST_ALGO_MD4: return "MD4";
|
|
|
|
default: return "unknown digest algorithm";
|
2012-08-30 19:26:35 +02:00
|
|
|
}
|
2020-11-28 09:15:49 +01:00
|
|
|
#pragma GCC diagnostic pop
|
2012-08-30 19:26:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* get data from the 'certificate' */
|
|
|
|
static char*
|
2021-10-20 11:18:15 +02:00
|
|
|
get_cert_data(GMimeCertificate* cert)
|
2012-08-30 19:26:35 +02:00
|
|
|
{
|
2021-10-20 11:18:15 +02:00
|
|
|
const char /**email,*/ *name, *digest_algo, *pubkey_algo, *keyid, *trust;
|
2012-08-30 19:26:35 +02:00
|
|
|
|
2012-09-19 10:36:02 +02:00
|
|
|
/* email = g_mime_certificate_get_email (cert); */
|
2021-10-20 11:18:15 +02:00
|
|
|
name = g_mime_certificate_get_name(cert);
|
|
|
|
keyid = g_mime_certificate_get_key_id(cert);
|
2012-08-30 19:26:35 +02:00
|
|
|
|
2021-10-20 11:18:15 +02:00
|
|
|
digest_algo = get_digestkey_algo_name(g_mime_certificate_get_digest_algo(cert));
|
|
|
|
pubkey_algo = get_pubkey_algo_name(g_mime_certificate_get_pubkey_algo(cert));
|
2012-08-30 19:26:35 +02:00
|
|
|
|
2021-10-20 11:18:15 +02:00
|
|
|
switch (g_mime_certificate_get_trust(cert)) {
|
|
|
|
case GMIME_TRUST_UNKNOWN: trust = "unknown"; break;
|
2017-07-30 16:47:38 +02:00
|
|
|
case GMIME_TRUST_UNDEFINED: trust = "undefined"; break;
|
2021-10-20 11:18:15 +02:00
|
|
|
case GMIME_TRUST_NEVER: trust = "never"; break;
|
|
|
|
case GMIME_TRUST_MARGINAL: trust = "marginal"; break;
|
|
|
|
case GMIME_TRUST_FULL: trust = "full"; break;
|
|
|
|
case GMIME_TRUST_ULTIMATE: trust = "ultimate"; break;
|
|
|
|
default: g_return_val_if_reached(NULL);
|
2012-08-30 19:26:35 +02:00
|
|
|
}
|
|
|
|
|
2021-10-20 11:18:15 +02:00
|
|
|
return g_strdup_printf("signer:%s, key:%s (%s,%s), trust:%s",
|
2022-02-22 21:48:29 +01:00
|
|
|
name ? name : "?",
|
|
|
|
/* email ? email : "?", */
|
|
|
|
keyid,
|
|
|
|
pubkey_algo,
|
|
|
|
digest_algo,
|
|
|
|
trust);
|
2012-08-30 19:26:35 +02:00
|
|
|
}
|
|
|
|
|
2020-01-22 19:56:50 +01:00
|
|
|
static char*
|
2021-10-20 11:18:15 +02:00
|
|
|
get_signature_status(GMimeSignatureStatus status)
|
2020-01-22 19:56:50 +01:00
|
|
|
{
|
2021-10-20 11:18:15 +02:00
|
|
|
size_t n;
|
|
|
|
GString* descr;
|
|
|
|
|
|
|
|
struct {
|
|
|
|
GMimeSignatureStatus status;
|
|
|
|
const char* name;
|
|
|
|
} status_info[] = {
|
|
|
|
{GMIME_SIGNATURE_STATUS_VALID, "valid"},
|
|
|
|
{GMIME_SIGNATURE_STATUS_GREEN, "green"},
|
|
|
|
{GMIME_SIGNATURE_STATUS_RED, "red"},
|
|
|
|
{GMIME_SIGNATURE_STATUS_KEY_REVOKED, "key revoked"},
|
|
|
|
{GMIME_SIGNATURE_STATUS_KEY_EXPIRED, "key expired"},
|
|
|
|
{GMIME_SIGNATURE_STATUS_SIG_EXPIRED, "signature expired"},
|
|
|
|
{GMIME_SIGNATURE_STATUS_KEY_MISSING, "key missing"},
|
|
|
|
{GMIME_SIGNATURE_STATUS_CRL_MISSING, "crl missing"},
|
|
|
|
{GMIME_SIGNATURE_STATUS_CRL_TOO_OLD, "crl too old"},
|
|
|
|
{GMIME_SIGNATURE_STATUS_BAD_POLICY, "bad policy"},
|
|
|
|
{GMIME_SIGNATURE_STATUS_SYS_ERROR, "system error"},
|
|
|
|
{GMIME_SIGNATURE_STATUS_TOFU_CONFLICT, "tofu conflict "},
|
|
|
|
};
|
|
|
|
|
|
|
|
descr = g_string_new("");
|
|
|
|
for (n = 0; n != G_N_ELEMENTS(status_info); ++n) {
|
|
|
|
if (!(status & status_info[n].status))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
g_string_append_printf(descr,
|
2022-02-22 21:48:29 +01:00
|
|
|
"%s%s",
|
|
|
|
descr->len > 0 ? ", " : "",
|
|
|
|
status_info[n].name);
|
2021-10-20 11:18:15 +02:00
|
|
|
}
|
2020-01-22 19:56:50 +01:00
|
|
|
|
2021-10-20 11:18:15 +02:00
|
|
|
return g_string_free(descr, FALSE);
|
|
|
|
}
|
2020-01-22 19:56:50 +01:00
|
|
|
|
2012-08-30 19:26:35 +02:00
|
|
|
/* get a human-readable report about the signature */
|
|
|
|
static char*
|
2021-10-20 11:18:15 +02:00
|
|
|
get_verdict_report(GMimeSignature* msig)
|
2012-08-30 19:26:35 +02:00
|
|
|
{
|
2022-02-22 21:48:29 +01:00
|
|
|
gchar * certdata, *report, *status;
|
|
|
|
GMimeSignatureStatus sigstat;
|
2017-07-30 16:47:38 +02:00
|
|
|
|
2021-10-20 11:18:15 +02:00
|
|
|
sigstat = g_mime_signature_get_status(msig);
|
|
|
|
status = get_signature_status(sigstat);
|
2012-08-30 19:26:35 +02:00
|
|
|
|
2022-02-22 21:48:29 +01:00
|
|
|
auto date_str = [](time_t t)->std::string {
|
|
|
|
if (t == 0 || t == static_cast<time_t>(-1))
|
|
|
|
return "?";
|
|
|
|
else
|
|
|
|
return time_to_string("%x", t);
|
|
|
|
};
|
2012-08-30 19:26:35 +02:00
|
|
|
|
2022-02-22 21:48:29 +01:00
|
|
|
const auto created = date_str(g_mime_signature_get_created(msig));
|
|
|
|
const auto expires = date_str(g_mime_signature_get_expires(msig));
|
2012-08-30 19:26:35 +02:00
|
|
|
|
2021-10-20 11:18:15 +02:00
|
|
|
certdata = get_cert_data(g_mime_signature_get_certificate(msig));
|
|
|
|
report = g_strdup_printf("%s; created:%s, expires:%s, %s",
|
2022-02-22 21:48:29 +01:00
|
|
|
status,
|
|
|
|
created.c_str(),
|
|
|
|
expires.c_str(),
|
|
|
|
certdata ? certdata : "?");
|
2021-10-20 11:18:15 +02:00
|
|
|
g_free(certdata);
|
|
|
|
g_free(status);
|
2020-01-22 19:56:50 +01:00
|
|
|
|
2012-08-30 19:26:35 +02:00
|
|
|
return report;
|
|
|
|
}
|
|
|
|
|
2017-08-27 16:32:23 +02:00
|
|
|
static char*
|
2021-10-20 11:18:15 +02:00
|
|
|
get_signers(GHashTable* signerhash)
|
2017-08-27 16:32:23 +02:00
|
|
|
{
|
2021-10-20 11:18:15 +02:00
|
|
|
GString* gstr;
|
|
|
|
GHashTableIter iter;
|
|
|
|
char* name;
|
2017-08-27 16:32:23 +02:00
|
|
|
|
|
|
|
if (!signerhash || g_hash_table_size(signerhash) == 0)
|
|
|
|
return NULL;
|
|
|
|
|
2021-10-20 11:18:15 +02:00
|
|
|
gstr = g_string_new(NULL);
|
|
|
|
g_hash_table_iter_init(&iter, signerhash);
|
2020-11-28 09:15:49 +01:00
|
|
|
|
2021-10-20 11:18:15 +02:00
|
|
|
while (g_hash_table_iter_next(&iter, reinterpret_cast<void**>(&name), NULL)) {
|
2017-08-27 16:32:23 +02:00
|
|
|
if (gstr->len != 0)
|
2021-10-20 11:18:15 +02:00
|
|
|
g_string_append_c(gstr, ',');
|
|
|
|
gstr = g_string_append(gstr, name);
|
2017-08-27 16:32:23 +02:00
|
|
|
}
|
|
|
|
|
2021-10-20 11:18:15 +02:00
|
|
|
return g_string_free(gstr, FALSE);
|
2017-08-27 16:32:23 +02:00
|
|
|
}
|
|
|
|
|
2012-08-30 19:26:35 +02:00
|
|
|
static MuMsgPartSigStatusReport*
|
2021-10-20 11:18:15 +02:00
|
|
|
get_status_report(GMimeSignatureList* sigs)
|
2012-07-17 18:15:47 +02:00
|
|
|
{
|
2021-10-20 11:18:15 +02:00
|
|
|
int i;
|
|
|
|
MuMsgPartSigStatus status;
|
|
|
|
MuMsgPartSigStatusReport* status_report;
|
|
|
|
char* report;
|
|
|
|
GHashTable* signerhash;
|
2012-07-17 18:15:47 +02:00
|
|
|
|
2021-10-20 11:18:15 +02:00
|
|
|
status = MU_MSG_PART_SIG_STATUS_GOOD; /* let's start positive! */
|
|
|
|
signerhash = g_hash_table_new(g_str_hash, g_str_equal);
|
2012-07-17 18:15:47 +02:00
|
|
|
|
2021-10-20 11:18:15 +02:00
|
|
|
for (i = 0, report = NULL; i != g_mime_signature_list_length(sigs); ++i) {
|
|
|
|
GMimeSignature* msig;
|
|
|
|
GMimeCertificate* cert;
|
|
|
|
GMimeSignatureStatus sigstat;
|
|
|
|
gchar* rep;
|
2012-07-17 18:15:47 +02:00
|
|
|
|
2021-10-20 11:18:15 +02:00
|
|
|
msig = g_mime_signature_list_get_signature(sigs, i);
|
|
|
|
sigstat = g_mime_signature_get_status(msig);
|
2012-07-17 18:15:47 +02:00
|
|
|
|
2017-07-30 16:47:38 +02:00
|
|
|
/* downgrade our expectations */
|
|
|
|
if ((sigstat & GMIME_SIGNATURE_STATUS_ERROR_MASK) &&
|
|
|
|
status != MU_MSG_PART_SIG_STATUS_ERROR)
|
2017-08-27 16:32:23 +02:00
|
|
|
status = MU_MSG_PART_SIG_STATUS_ERROR;
|
2017-07-30 16:47:38 +02:00
|
|
|
else if ((sigstat & GMIME_SIGNATURE_STATUS_RED) &&
|
2022-02-22 21:48:29 +01:00
|
|
|
status == MU_MSG_PART_SIG_STATUS_GOOD)
|
2017-08-27 16:32:23 +02:00
|
|
|
status = MU_MSG_PART_SIG_STATUS_BAD;
|
2012-08-30 19:26:35 +02:00
|
|
|
|
2021-10-20 11:18:15 +02:00
|
|
|
rep = get_verdict_report(msig);
|
|
|
|
report = g_strdup_printf("%s%s%d: %s",
|
2022-02-22 21:48:29 +01:00
|
|
|
report ? report : "",
|
|
|
|
report ? "; " : "",
|
|
|
|
i + 1,
|
|
|
|
rep);
|
2021-10-20 11:18:15 +02:00
|
|
|
g_free(rep);
|
|
|
|
|
|
|
|
cert = g_mime_signature_get_certificate(msig);
|
|
|
|
if (cert && g_mime_certificate_get_name(cert))
|
|
|
|
g_hash_table_add(signerhash, (gpointer)g_mime_certificate_get_name(cert));
|
2012-07-17 18:15:47 +02:00
|
|
|
}
|
|
|
|
|
2021-10-20 11:18:15 +02:00
|
|
|
status_report = g_slice_new0(MuMsgPartSigStatusReport);
|
2017-08-27 16:32:23 +02:00
|
|
|
|
2012-08-30 19:26:35 +02:00
|
|
|
status_report->verdict = status;
|
|
|
|
status_report->report = report;
|
2017-08-27 16:32:23 +02:00
|
|
|
status_report->signers = get_signers(signerhash);
|
|
|
|
|
2021-10-20 11:18:15 +02:00
|
|
|
g_hash_table_unref(signerhash);
|
2012-08-30 19:26:35 +02:00
|
|
|
|
|
|
|
return status_report;
|
2012-07-17 18:15:47 +02:00
|
|
|
}
|
|
|
|
|
2012-08-30 19:26:35 +02:00
|
|
|
void
|
2021-10-20 11:18:15 +02:00
|
|
|
Mu::mu_msg_part_sig_status_report_destroy(MuMsgPartSigStatusReport* report)
|
2012-08-30 19:26:35 +02:00
|
|
|
{
|
|
|
|
if (!report)
|
|
|
|
return;
|
|
|
|
|
2021-10-20 11:18:15 +02:00
|
|
|
g_free((char*)report->report);
|
|
|
|
g_free((char*)report->signers);
|
2017-08-27 16:32:23 +02:00
|
|
|
|
2021-10-20 11:18:15 +02:00
|
|
|
g_slice_free(MuMsgPartSigStatusReport, report);
|
2012-08-30 19:26:35 +02:00
|
|
|
}
|
2012-07-17 18:15:47 +02:00
|
|
|
|
2015-02-14 23:07:38 +01:00
|
|
|
static inline void
|
2021-10-20 11:18:15 +02:00
|
|
|
tag_with_sig_status(GObject* part, MuMsgPartSigStatusReport* report)
|
2015-02-14 23:07:38 +01:00
|
|
|
{
|
2021-10-20 11:18:15 +02:00
|
|
|
g_object_set_data_full(part,
|
2022-02-22 21:48:29 +01:00
|
|
|
SIG_STATUS_REPORT,
|
|
|
|
report,
|
|
|
|
(GDestroyNotify)mu_msg_part_sig_status_report_destroy);
|
2015-02-14 23:07:38 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2021-10-20 11:18:15 +02:00
|
|
|
Mu::mu_msg_crypto_verify_part(GMimeMultipartSigned* sig, MuMsgOptions opts, GError** err)
|
2012-07-18 16:52:33 +02:00
|
|
|
{
|
2015-02-14 23:07:38 +01:00
|
|
|
/* the signature status */
|
2021-10-20 11:18:15 +02:00
|
|
|
MuMsgPartSigStatusReport* report;
|
|
|
|
GMimeSignatureList* sigs;
|
2012-07-18 16:52:33 +02:00
|
|
|
|
2021-10-20 11:18:15 +02:00
|
|
|
g_return_if_fail(GMIME_IS_MULTIPART_SIGNED(sig));
|
2012-07-18 16:52:33 +02:00
|
|
|
|
2021-10-20 11:18:15 +02:00
|
|
|
sigs = g_mime_multipart_signed_verify(sig, GMIME_VERIFY_NONE, err);
|
2012-08-30 11:53:52 +02:00
|
|
|
if (!sigs) {
|
|
|
|
if (err && !*err)
|
2021-10-20 11:18:15 +02:00
|
|
|
mu_util_g_set_error(err, MU_ERROR_CRYPTO, "verification failed");
|
2015-02-14 23:07:38 +01:00
|
|
|
return;
|
2012-07-17 18:15:47 +02:00
|
|
|
}
|
|
|
|
|
2021-10-20 11:18:15 +02:00
|
|
|
report = get_status_report(sigs);
|
|
|
|
g_clear_object(&sigs);
|
2012-07-17 18:15:47 +02:00
|
|
|
|
2015-02-14 23:07:38 +01:00
|
|
|
/* tag this part with the signature status check */
|
|
|
|
tag_with_sig_status(G_OBJECT(sig), report);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
2021-10-20 11:18:15 +02:00
|
|
|
check_decrypt_result(GMimeMultipartEncrypted* part, GMimeDecryptResult* res, GError** err)
|
2015-02-14 23:07:38 +01:00
|
|
|
{
|
2021-10-20 11:18:15 +02:00
|
|
|
GMimeSignatureList* sigs;
|
|
|
|
MuMsgPartSigStatusReport* report;
|
2015-02-14 23:07:38 +01:00
|
|
|
|
|
|
|
if (res) {
|
|
|
|
/* Check if the decrypted part had any embed signatures */
|
|
|
|
sigs = res->signatures;
|
|
|
|
if (sigs) {
|
2021-10-20 11:18:15 +02:00
|
|
|
report = get_status_report(sigs);
|
|
|
|
g_mime_signature_list_clear(sigs);
|
2015-02-14 23:07:38 +01:00
|
|
|
|
|
|
|
/* tag this part with the signature status check */
|
|
|
|
tag_with_sig_status(G_OBJECT(part), report);
|
2021-10-20 11:18:15 +02:00
|
|
|
} else {
|
2015-02-14 23:07:38 +01:00
|
|
|
if (err && !*err)
|
2021-10-20 11:18:15 +02:00
|
|
|
mu_util_g_set_error(err, MU_ERROR_CRYPTO, "verification failed");
|
2015-02-14 23:07:38 +01:00
|
|
|
}
|
2021-10-20 11:18:15 +02:00
|
|
|
g_object_unref(res);
|
2015-02-14 23:07:38 +01:00
|
|
|
}
|
2012-07-18 09:30:23 +02:00
|
|
|
}
|
|
|
|
|
2012-07-27 17:02:34 +02:00
|
|
|
GMimeObject* /* this is declared in mu-msg-priv.h */
|
2021-10-20 11:18:15 +02:00
|
|
|
Mu::mu_msg_crypto_decrypt_part(GMimeMultipartEncrypted* enc,
|
2022-02-22 21:48:29 +01:00
|
|
|
MuMsgOptions opts,
|
|
|
|
MuMsgPartPasswordFunc func,
|
|
|
|
gpointer user_data,
|
|
|
|
GError** err)
|
2012-07-22 18:39:17 +02:00
|
|
|
{
|
2021-10-20 11:18:15 +02:00
|
|
|
GMimeObject* dec;
|
|
|
|
GMimeDecryptResult* res;
|
2012-07-22 18:39:17 +02:00
|
|
|
|
2021-10-20 11:18:15 +02:00
|
|
|
g_return_val_if_fail(GMIME_IS_MULTIPART_ENCRYPTED(enc), NULL);
|
2012-07-22 18:39:17 +02:00
|
|
|
|
2012-09-13 20:11:26 +02:00
|
|
|
res = NULL;
|
2021-10-20 11:18:15 +02:00
|
|
|
dec = g_mime_multipart_encrypted_decrypt(enc, GMIME_DECRYPT_NONE, NULL, &res, err);
|
2015-02-14 23:07:38 +01:00
|
|
|
check_decrypt_result(enc, res, err);
|
2012-09-13 20:11:26 +02:00
|
|
|
|
2012-07-27 17:02:34 +02:00
|
|
|
if (!dec) {
|
|
|
|
if (err && !*err)
|
2021-10-20 11:18:15 +02:00
|
|
|
mu_util_g_set_error(err, MU_ERROR_CRYPTO, "decryption failed");
|
2012-07-22 18:39:17 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-07-27 17:02:34 +02:00
|
|
|
return dec;
|
2012-07-22 18:39:17 +02:00
|
|
|
}
|