git.notmuchmail.org Git - notmuch/blob - util/crypto.c

   1 /* notmuch - Not much of an email program, (just index and search)
   2  *
   3  * Copyright © 2012 Jameson Rollins
   4  *
   5  * This program is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation, either version 3 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see https://www.gnu.org/licenses/ .
  17  *
  18  * Authors: Jameson Rollins <jrollins@finestructure.net>
  19  */
  20
  21 #include "crypto.h"
  22 #include <strings.h>
  23 #define unused(x) x __attribute__ ((unused))
  24
  25 #define ARRAY_SIZE(arr) (sizeof (arr) / sizeof (arr[0]))
  26
  27 void _notmuch_crypto_cleanup (unused(_notmuch_crypto_t *crypto))
  28 {
  29 }
  30
  31 GMimeObject *
  32 _notmuch_crypto_decrypt (bool *attempted,
  33                          notmuch_decryption_policy_t decrypt,
  34                          notmuch_message_t *message,
  35                          GMimeMultipartEncrypted *part,
  36                          GMimeDecryptResult **decrypt_result,
  37                          GError **err)
  38 {
  39     GMimeObject *ret = NULL;
  40     if (decrypt == NOTMUCH_DECRYPT_FALSE)
  41         return NULL;
  42
  43     /* try decryption with session key if one is stashed */
  44     if (message) {
  45         notmuch_message_properties_t *list = NULL;
  46
  47         for (list = notmuch_message_get_properties (message, "session-key", TRUE);
  48              notmuch_message_properties_valid (list); notmuch_message_properties_move_to_next (list)) {
  49             if (err && *err) {
  50                 g_error_free (*err);
  51                 *err = NULL;
  52             }
  53             if (attempted)
  54                 *attempted = true;
  55             ret = g_mime_multipart_encrypted_decrypt (part,
  56                                                       GMIME_DECRYPT_NONE,
  57                                                       notmuch_message_properties_value (list),
  58                                                       decrypt_result, err);
  59             if (ret)
  60                 break;
  61         }
  62         if (list)
  63             notmuch_message_properties_destroy (list);
  64         if (ret)
  65             return ret;
  66     }
  67
  68     if (err && *err) {
  69         g_error_free (*err);
  70         *err = NULL;
  71     }
  72
  73     if (decrypt == NOTMUCH_DECRYPT_AUTO)
  74         return ret;
  75
  76     if (attempted)
  77         *attempted = true;
  78     GMimeDecryptFlags flags = GMIME_DECRYPT_NONE;
  79     if (decrypt == NOTMUCH_DECRYPT_TRUE && decrypt_result)
  80         flags |= GMIME_DECRYPT_EXPORT_SESSION_KEY;
  81     ret = g_mime_multipart_encrypted_decrypt(part, flags, NULL,
  82                                              decrypt_result, err);
  83     return ret;
  84 }
  85
  86 static int
  87 _notmuch_message_crypto_destructor (_notmuch_message_crypto_t *msg_crypto)
  88 {
  89     if (!msg_crypto)
  90         return 0;
  91     if (msg_crypto->sig_list)
  92         g_object_unref (msg_crypto->sig_list);
  93     return 0;
  94 }
  95
  96 _notmuch_message_crypto_t *
  97 _notmuch_message_crypto_new (void *ctx)
  98 {
  99     _notmuch_message_crypto_t *ret = talloc_zero (ctx, _notmuch_message_crypto_t);
 100     talloc_set_destructor (ret, _notmuch_message_crypto_destructor);
 101     return ret;
 102 }
 103
 104 notmuch_status_t
 105 _notmuch_message_crypto_potential_sig_list (_notmuch_message_crypto_t *msg_crypto, GMimeSignatureList *sigs)
 106 {
 107     if (!msg_crypto)
 108         return NOTMUCH_STATUS_NULL_POINTER;
 109
 110     /* Signatures that arrive after a payload part during DFS are not
 111      * part of the cryptographic envelope: */
 112     if (msg_crypto->payload_encountered)
 113         return NOTMUCH_STATUS_SUCCESS;
 114
 115     if (msg_crypto->sig_list)
 116         g_object_unref (msg_crypto->sig_list);
 117
 118     /* This signature list needs to persist as long as the _n_m_crypto
 119      * object survives. Increasing its reference counter prevents
 120      * garbage-collection until after _n_m_crypto_destroy is
 121      * called. */
 122     msg_crypto->sig_list = sigs;
 123     if (sigs)
 124         g_object_ref (sigs);
 125
 126     if (msg_crypto->decryption_status == NOTMUCH_MESSAGE_DECRYPTED_FULL)
 127         msg_crypto->signature_encrypted = true;
 128
 129     return NOTMUCH_STATUS_SUCCESS;
 130 }
 131
 132
 133 notmuch_status_t
 134 _notmuch_message_crypto_potential_payload (_notmuch_message_crypto_t *msg_crypto, GMimeObject *payload, GMimeObject *parent, int childnum)
 135 {
 136     if (!msg_crypto || !payload)
 137         return NOTMUCH_STATUS_NULL_POINTER;
 138
 139     /* only fire on the first payload part encountered */
 140     if (msg_crypto->payload_encountered)
 141         return NOTMUCH_STATUS_SUCCESS;
 142
 143     /* the first child of multipart/encrypted that matches the
 144      * encryption protocol should be "control information" metadata,
 145      * not payload.  So we skip it. (see
 146      * https://tools.ietf.org/html/rfc1847#page-8) */
 147     if (parent && GMIME_IS_MULTIPART_ENCRYPTED (parent) && childnum == GMIME_MULTIPART_ENCRYPTED_VERSION) {
 148         const char *enc_type = g_mime_object_get_content_type_parameter (parent, "protocol");
 149         GMimeContentType *ct = g_mime_object_get_content_type (payload);
 150         if (ct && enc_type) {
 151             const char *part_type = g_mime_content_type_get_mime_type (ct);
 152             if (part_type && strcmp (part_type, enc_type) == 0)
 153                 return NOTMUCH_STATUS_SUCCESS;
 154         }
 155     }
 156
 157     msg_crypto->payload_encountered = true;
 158
 159     return NOTMUCH_STATUS_SUCCESS;
 160 }
 161
 162
 163 notmuch_status_t
 164 _notmuch_message_crypto_successful_decryption (_notmuch_message_crypto_t *msg_crypto)
 165 {
 166     if (!msg_crypto)
 167         return NOTMUCH_STATUS_NULL_POINTER;
 168
 169     /* see the rationale for different values of
 170      * _notmuch_message_decryption_status_t in util/crypto.h */
 171     if (!msg_crypto->payload_encountered)
 172         msg_crypto->decryption_status = NOTMUCH_MESSAGE_DECRYPTED_FULL;
 173     else if (msg_crypto->decryption_status == NOTMUCH_MESSAGE_DECRYPTED_NONE)
 174         msg_crypto->decryption_status = NOTMUCH_MESSAGE_DECRYPTED_PARTIAL;
 175
 176     return NOTMUCH_STATUS_SUCCESS;
 177 }