We add a new message flag that indicates desire for indexing the cleartext of a given message. If that flag is set while indexing, we'll try to descend into it. If we can decrypt, we tag the message with index-decrypted. If we can't decrypt (or recognize the encrypted type of mail), we tag with decryption-failed. Note that a single message may be tagged with "encrypted" and "index-decrypted" and "decryption-failed". For example, consider a message that includes multiple layers of encryption. It is automatically tagged with "encrypted". If we decrypt the outer layer ("index-decrypted"), but fail on the inner layer ("decryption-failed"). --- lib/index.cc | 52 +++++++++++++++++++++++++++++++++++++++++++++++++++- lib/notmuch.h | 5 +++++ 2 files changed, 56 insertions(+), 1 deletion(-) diff --git a/lib/index.cc b/lib/index.cc index 2fa6616..bd028cb 100644 --- a/lib/index.cc +++ b/lib/index.cc @@ -300,6 +300,10 @@ _index_address_list (notmuch_message_t *message, } } +static void +_index_encrypted_mime_part (notmuch_message_t *message, GMimeContentType *content_type, + GMimeMultipartEncrypted *part); + /* Callback to generate terms for each mime part of a message. */ static void _index_mime_part (notmuch_message_t *message, @@ -346,7 +350,10 @@ _index_mime_part (notmuch_message_t *message, _notmuch_database_log (_notmuch_message_database (message), "Warning: Unexpected extra parts of multipart/signed. Indexing anyway.\n"); } else if (GMIME_IS_MULTIPART_ENCRYPTED (multipart)) { - /* Don't index encrypted parts */ + _notmuch_message_add_term (message, "tag", "encrypted"); + if (notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_INDEX_DECRYPTED)) { + _index_encrypted_mime_part(message, content_type, GMIME_MULTIPART_ENCRYPTED (part)); + } } else { for (i = 0; i < g_mime_multipart_get_count (multipart); i++) { _index_mime_part (message, @@ -431,6 +438,49 @@ _index_mime_part (notmuch_message_t *message, } } +/* descend (if possible) into the cleartext part of an encrypted MIME + * part while indexing. */ +static void +_index_encrypted_mime_part (notmuch_message_t *message, + GMimeContentType *content_type, + GMimeMultipartEncrypted *encrypted_data) +{ + notmuch_private_status_t status; + GMimeCryptoContext* crypto_ctx = NULL; + const char *protocol = g_mime_content_type_get_parameter (content_type, "protocol"); + GError *err = NULL; + notmuch_database_t * notmuch = _notmuch_message_database (message); + GMimeObject *clear = NULL; + + status = _notmuch_database_get_crypto_for_protocol (notmuch, protocol, + &crypto_ctx); + if (status) { + _notmuch_database_log (notmuch, "Warning: setup failed for decrypting " + "during indexing. (%d)\n", status); + _notmuch_message_add_term (message, "tag", "index-decryption-failed"); + return; + } + + /* we don't need the GMimeDecryptResult, because we're not looking + * at validating signatures, and we don't care about indexing who + * the message was ostensibly encrypted to. + */ + clear = g_mime_multipart_encrypted_decrypt(encrypted_data, crypto_ctx, + NULL, &err); + if (err) { + _notmuch_database_log (notmuch, "Failed to decrypt during indexing. (%d:%d) [%s]\n", + err->domain, err->code, err->message); + g_error_free(err); + /* Indicate that we failed to decrypt during indexing */ + _notmuch_message_add_term (message, "tag", "index-decryption-failed"); + return; + } + _index_mime_part (message, clear); + g_object_unref (clear); + + _notmuch_message_add_term (message, "tag", "index-decrypted"); +} + notmuch_status_t _notmuch_message_index_file (notmuch_message_t *message, notmuch_message_file_t *message_file) diff --git a/lib/notmuch.h b/lib/notmuch.h index 310a8b8..e7085b7 100644 --- a/lib/notmuch.h +++ b/lib/notmuch.h @@ -1357,6 +1357,11 @@ typedef enum _notmuch_message_flag { * thread ID. */ NOTMUCH_MESSAGE_FLAG_GHOST, + + /* Some part(s) of this message is encrypted, but the message is + * indexed in the clear. + */ + NOTMUCH_MESSAGE_FLAG_INDEX_DECRYPTED } notmuch_message_flag_t; /** -- 2.6.2