]> git.cworth.org Git - notmuch/blob - util/crypto.c
mime-node: track whole-message crypto state while walking the tree
[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 _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 }