X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=util%2Fcrypto.c;h=225f537a0b55e331433d7371f18a8874a69d33e0;hp=8104263d1ace559d8928fd37326d0beb30b32099;hb=b23902a61158ecdbca2d9d96c6eaf509d6e3d205;hpb=bb0b119358e4d6df5cc085a48cb3d2e09e396922 diff --git a/util/crypto.c b/util/crypto.c index 8104263d..225f537a 100644 --- a/util/crypto.c +++ b/util/crypto.c @@ -24,7 +24,8 @@ #define ARRAY_SIZE(arr) (sizeof (arr) / sizeof (arr[0])) -void _notmuch_crypto_cleanup (unused(_notmuch_crypto_t *crypto)) +void +_notmuch_crypto_cleanup (unused(_notmuch_crypto_t *crypto)) { } @@ -32,16 +33,16 @@ GMimeObject * _notmuch_crypto_decrypt (bool *attempted, notmuch_decryption_policy_t decrypt, notmuch_message_t *message, - g_mime_3_unused(GMimeCryptoContext* crypto_ctx), GMimeMultipartEncrypted *part, GMimeDecryptResult **decrypt_result, GError **err) { GMimeObject *ret = NULL; + if (decrypt == NOTMUCH_DECRYPT_FALSE) return NULL; - /* the versions of notmuch that can support session key decryption */ + /* try decryption with session key if one is stashed */ if (message) { notmuch_message_properties_t *list = NULL; @@ -79,7 +80,138 @@ _notmuch_crypto_decrypt (bool *attempted, GMimeDecryptFlags flags = GMIME_DECRYPT_NONE; if (decrypt == NOTMUCH_DECRYPT_TRUE && decrypt_result) flags |= GMIME_DECRYPT_EXPORT_SESSION_KEY; - ret = g_mime_multipart_encrypted_decrypt(part, flags, NULL, - decrypt_result, err); + ret = g_mime_multipart_encrypted_decrypt (part, flags, NULL, + decrypt_result, err); + return ret; +} + +static int +_notmuch_message_crypto_destructor (_notmuch_message_crypto_t *msg_crypto) +{ + if (! msg_crypto) + return 0; + if (msg_crypto->sig_list) + g_object_unref (msg_crypto->sig_list); + if (msg_crypto->payload_subject) + talloc_free (msg_crypto->payload_subject); + return 0; +} + +_notmuch_message_crypto_t * +_notmuch_message_crypto_new (void *ctx) +{ + _notmuch_message_crypto_t *ret = talloc_zero (ctx, _notmuch_message_crypto_t); + + talloc_set_destructor (ret, _notmuch_message_crypto_destructor); return ret; } + +notmuch_status_t +_notmuch_message_crypto_potential_sig_list (_notmuch_message_crypto_t *msg_crypto, GMimeSignatureList *sigs) +{ + if (! msg_crypto) + return NOTMUCH_STATUS_NULL_POINTER; + + /* Signatures that arrive after a payload part during DFS are not + * part of the cryptographic envelope: */ + if (msg_crypto->payload_encountered) + return NOTMUCH_STATUS_SUCCESS; + + if (msg_crypto->sig_list) + g_object_unref (msg_crypto->sig_list); + + /* This signature list needs to persist as long as the _n_m_crypto + * object survives. Increasing its reference counter prevents + * garbage-collection until after _n_m_crypto_destroy is + * called. */ + msg_crypto->sig_list = sigs; + if (sigs) + g_object_ref (sigs); + + if (msg_crypto->decryption_status == NOTMUCH_MESSAGE_DECRYPTED_FULL) + msg_crypto->signature_encrypted = true; + + return NOTMUCH_STATUS_SUCCESS; +} + + +notmuch_status_t +_notmuch_message_crypto_potential_payload (_notmuch_message_crypto_t *msg_crypto, GMimeObject *payload, GMimeObject *parent, int childnum) +{ + const char *protected_headers = NULL; + const char *forwarded = NULL; + const char *subject = NULL; + + if (! msg_crypto || ! payload) + return NOTMUCH_STATUS_NULL_POINTER; + + /* only fire on the first payload part encountered */ + if (msg_crypto->payload_encountered) + return NOTMUCH_STATUS_SUCCESS; + + /* the first child of multipart/encrypted that matches the + * encryption protocol should be "control information" metadata, + * not payload. So we skip it. (see + * https://tools.ietf.org/html/rfc1847#page-8) */ + if (parent && GMIME_IS_MULTIPART_ENCRYPTED (parent) && childnum == GMIME_MULTIPART_ENCRYPTED_VERSION) { + const char *enc_type = g_mime_object_get_content_type_parameter (parent, "protocol"); + GMimeContentType *ct = g_mime_object_get_content_type (payload); + if (ct && enc_type) { + const char *part_type = g_mime_content_type_get_mime_type (ct); + if (part_type && strcmp (part_type, enc_type) == 0) + return NOTMUCH_STATUS_SUCCESS; + } + } + + msg_crypto->payload_encountered = true; + + /* don't bother recording anything if there is no cryptographic + * envelope: */ + if ((msg_crypto->decryption_status != NOTMUCH_MESSAGE_DECRYPTED_FULL) && + (msg_crypto->sig_list == NULL)) + return NOTMUCH_STATUS_SUCCESS; + + /* Verify that this payload has headers that are intended to be + * exported to the larger message: */ + + /* Consider a payload that uses Alexei Melinkov's forwarded="no" for + * message/global or message/rfc822: + * https://tools.ietf.org/html/draft-melnikov-smime-header-signing-05#section-4 */ + forwarded = g_mime_object_get_content_type_parameter (payload, "forwarded"); + if (GMIME_IS_MESSAGE_PART (payload) && forwarded && strcmp (forwarded, "no") == 0) { + GMimeMessage *message = g_mime_message_part_get_message (GMIME_MESSAGE_PART (payload)); + subject = g_mime_message_get_subject (message); + /* FIXME: handle more than just Subject: at some point */ + } else { + /* Consider "memoryhole"-style protected headers as practiced by Enigmail and K-9 */ + protected_headers = g_mime_object_get_content_type_parameter (payload, "protected-headers"); + if (protected_headers && strcasecmp ("v1", protected_headers) == 0) + subject = g_mime_object_get_header (payload, "Subject"); + /* FIXME: handle more than just Subject: at some point */ + } + + if (subject) { + if (msg_crypto->payload_subject) + talloc_free (msg_crypto->payload_subject); + msg_crypto->payload_subject = talloc_strdup (msg_crypto, subject); + } + + return NOTMUCH_STATUS_SUCCESS; +} + + +notmuch_status_t +_notmuch_message_crypto_successful_decryption (_notmuch_message_crypto_t *msg_crypto) +{ + if (! msg_crypto) + return NOTMUCH_STATUS_NULL_POINTER; + + /* see the rationale for different values of + * _notmuch_message_decryption_status_t in util/crypto.h */ + if (! msg_crypto->payload_encountered) + msg_crypto->decryption_status = NOTMUCH_MESSAGE_DECRYPTED_FULL; + else if (msg_crypto->decryption_status == NOTMUCH_MESSAGE_DECRYPTED_NONE) + msg_crypto->decryption_status = NOTMUCH_MESSAGE_DECRYPTED_PARTIAL; + + return NOTMUCH_STATUS_SUCCESS; +}