Merge branch 'release'
[notmuch] / 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
28 _notmuch_crypto_cleanup (unused(_notmuch_crypto_t *crypto))
29 {
30 }
31
32 GMimeObject *
33 _notmuch_crypto_decrypt (bool *attempted,
34                          notmuch_decryption_policy_t decrypt,
35                          notmuch_message_t *message,
36                          GMimeMultipartEncrypted *part,
37                          GMimeDecryptResult **decrypt_result,
38                          GError **err)
39 {
40     GMimeObject *ret = NULL;
41
42     if (decrypt == NOTMUCH_DECRYPT_FALSE)
43         return NULL;
44
45     /* try decryption with session key if one is stashed */
46     if (message) {
47         notmuch_message_properties_t *list = NULL;
48
49         for (list = notmuch_message_get_properties (message, "session-key", TRUE);
50              notmuch_message_properties_valid (list); notmuch_message_properties_move_to_next (list)) {
51             if (err && *err) {
52                 g_error_free (*err);
53                 *err = NULL;
54             }
55             if (attempted)
56                 *attempted = true;
57             ret = g_mime_multipart_encrypted_decrypt (part,
58                                                       GMIME_DECRYPT_NONE,
59                                                       notmuch_message_properties_value (list),
60                                                       decrypt_result, err);
61             if (ret)
62                 break;
63         }
64         if (list)
65             notmuch_message_properties_destroy (list);
66         if (ret)
67             return ret;
68     }
69
70     if (err && *err) {
71         g_error_free (*err);
72         *err = NULL;
73     }
74
75     if (decrypt == NOTMUCH_DECRYPT_AUTO)
76         return ret;
77
78     if (attempted)
79         *attempted = true;
80     GMimeDecryptFlags flags = GMIME_DECRYPT_NONE;
81     if (decrypt == NOTMUCH_DECRYPT_TRUE && decrypt_result)
82         flags |= GMIME_DECRYPT_EXPORT_SESSION_KEY;
83     ret = g_mime_multipart_encrypted_decrypt (part, flags, NULL,
84                                               decrypt_result, err);
85     return ret;
86 }
87
88 static int
89 _notmuch_message_crypto_destructor (_notmuch_message_crypto_t *msg_crypto)
90 {
91     if (! msg_crypto)
92         return 0;
93     if (msg_crypto->sig_list)
94         g_object_unref (msg_crypto->sig_list);
95     if (msg_crypto->payload_subject)
96         talloc_free (msg_crypto->payload_subject);
97     return 0;
98 }
99
100 _notmuch_message_crypto_t *
101 _notmuch_message_crypto_new (void *ctx)
102 {
103     _notmuch_message_crypto_t *ret = talloc_zero (ctx, _notmuch_message_crypto_t);
104
105     talloc_set_destructor (ret, _notmuch_message_crypto_destructor);
106     return ret;
107 }
108
109 notmuch_status_t
110 _notmuch_message_crypto_potential_sig_list (_notmuch_message_crypto_t *msg_crypto, GMimeSignatureList *sigs)
111 {
112     if (! msg_crypto)
113         return NOTMUCH_STATUS_NULL_POINTER;
114
115     /* Signatures that arrive after a payload part during DFS are not
116      * part of the cryptographic envelope: */
117     if (msg_crypto->payload_encountered)
118         return NOTMUCH_STATUS_SUCCESS;
119
120     if (msg_crypto->sig_list)
121         g_object_unref (msg_crypto->sig_list);
122
123     /* This signature list needs to persist as long as the _n_m_crypto
124      * object survives. Increasing its reference counter prevents
125      * garbage-collection until after _n_m_crypto_destroy is
126      * called. */
127     msg_crypto->sig_list = sigs;
128     if (sigs)
129         g_object_ref (sigs);
130
131     if (msg_crypto->decryption_status == NOTMUCH_MESSAGE_DECRYPTED_FULL)
132         msg_crypto->signature_encrypted = true;
133
134     return NOTMUCH_STATUS_SUCCESS;
135 }
136
137
138 notmuch_status_t
139 _notmuch_message_crypto_potential_payload (_notmuch_message_crypto_t *msg_crypto, GMimeObject *payload, GMimeObject *parent, int childnum)
140 {
141     const char *protected_headers = NULL;
142     const char *forwarded = NULL;
143     const char *subject = NULL;
144
145     if (! msg_crypto || ! payload)
146         return NOTMUCH_STATUS_NULL_POINTER;
147
148     /* only fire on the first payload part encountered */
149     if (msg_crypto->payload_encountered)
150         return NOTMUCH_STATUS_SUCCESS;
151
152     /* the first child of multipart/encrypted that matches the
153      * encryption protocol should be "control information" metadata,
154      * not payload.  So we skip it. (see
155      * https://tools.ietf.org/html/rfc1847#page-8) */
156     if (parent && GMIME_IS_MULTIPART_ENCRYPTED (parent) && childnum == GMIME_MULTIPART_ENCRYPTED_VERSION) {
157         const char *enc_type = g_mime_object_get_content_type_parameter (parent, "protocol");
158         GMimeContentType *ct = g_mime_object_get_content_type (payload);
159         if (ct && enc_type) {
160             const char *part_type = g_mime_content_type_get_mime_type (ct);
161             if (part_type && strcmp (part_type, enc_type) == 0)
162                 return NOTMUCH_STATUS_SUCCESS;
163         }
164     }
165
166     msg_crypto->payload_encountered = true;
167
168     /* don't bother recording anything if there is no cryptographic
169      * envelope: */
170     if ((msg_crypto->decryption_status != NOTMUCH_MESSAGE_DECRYPTED_FULL) &&
171         (msg_crypto->sig_list == NULL))
172         return NOTMUCH_STATUS_SUCCESS;
173
174     /* Verify that this payload has headers that are intended to be
175      * exported to the larger message: */
176
177     /* Consider a payload that uses Alexei Melinkov's forwarded="no" for
178      * message/global or message/rfc822:
179      * https://tools.ietf.org/html/draft-melnikov-smime-header-signing-05#section-4 */
180     forwarded = g_mime_object_get_content_type_parameter (payload, "forwarded");
181     if (GMIME_IS_MESSAGE_PART (payload) && forwarded && strcmp (forwarded, "no") == 0) {
182         GMimeMessage *message = g_mime_message_part_get_message (GMIME_MESSAGE_PART (payload));
183         subject = g_mime_message_get_subject (message);
184         /* FIXME: handle more than just Subject: at some point */
185     } else {
186         /* Consider "memoryhole"-style protected headers as practiced by Enigmail and K-9 */
187         protected_headers = g_mime_object_get_content_type_parameter (payload, "protected-headers");
188         if (protected_headers && strcasecmp ("v1", protected_headers) == 0)
189             subject = g_mime_object_get_header (payload, "Subject");
190         /* FIXME: handle more than just Subject: at some point */
191     }
192
193     if (subject) {
194         if (msg_crypto->payload_subject)
195             talloc_free (msg_crypto->payload_subject);
196         msg_crypto->payload_subject = talloc_strdup (msg_crypto, subject);
197     }
198
199     return NOTMUCH_STATUS_SUCCESS;
200 }
201
202
203 notmuch_status_t
204 _notmuch_message_crypto_successful_decryption (_notmuch_message_crypto_t *msg_crypto)
205 {
206     if (! msg_crypto)
207         return NOTMUCH_STATUS_NULL_POINTER;
208
209     /* see the rationale for different values of
210      * _notmuch_message_decryption_status_t in util/crypto.h */
211     if (! msg_crypto->payload_encountered)
212         msg_crypto->decryption_status = NOTMUCH_MESSAGE_DECRYPTED_FULL;
213     else if (msg_crypto->decryption_status == NOTMUCH_MESSAGE_DECRYPTED_NONE)
214         msg_crypto->decryption_status = NOTMUCH_MESSAGE_DECRYPTED_PARTIAL;
215
216     return NOTMUCH_STATUS_SUCCESS;
217 }