enable storing of GnuPG passphrase
[claws.git] / src / pgptext.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 2001 Jens Jahnke <jan0sch@gmx.net>
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 2 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, write to the Free Software
17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18  */
19
20 #ifdef HAVE_CONFIG_H
21 #  include "config.h"
22 #endif
23
24 #if USE_GPGME
25
26 #include "defs.h"
27
28 #include <glib.h>
29 #include <stdio.h>
30 #include <string.h>
31 #include <locale.h>
32 #include <ctype.h>
33
34 #include <gpgme.h>
35
36 #include "intl.h"
37 #include "procmime.h"
38 #include "procheader.h"
39 #include "base64.h"
40 #include "uuencode.h"
41 #include "unmime.h"
42 #include "codeconv.h"
43 #include "utils.h"
44 #include "prefs_common.h"
45 #include "passphrase.h"
46 #include "select-keys.h"
47 #include "sigstatus.h"
48 #include "rfc2015.h"
49
50 #include "pgptext.h"
51
52 #define DIM(v)     (sizeof(v)/sizeof((v)[0]))
53
54 static char *content_names[] = {
55     "Content-Type",
56     "Content-Disposition",
57     "Content-Transfer-Encoding",
58     NULL
59 };
60
61 static char *mime_version_name[] = {
62     "Mime-Version",
63     NULL
64 };
65
66 /* stolen from rfc2015.c */
67 static int
68 gpg_name_cmp(const char *a, const char *b)
69 {
70     for( ; *a && *b; a++, b++) {
71         if(*a != *b
72            && toupper(*(unsigned char *)a) != toupper(*(unsigned char *)b))
73             return 1;
74     }
75
76     return *a != *b;
77 }
78
79 static GpgmeData
80 pgptext_decrypt (MimeInfo *partinfo, FILE *fp)
81 {
82     GpgmeCtx ctx = NULL;
83     GpgmeError err;
84     GpgmeData cipher = NULL, plain = NULL;
85     struct passphrase_cb_info_s info;
86
87     memset (&info, 0, sizeof info);
88
89     err = gpgme_new (&ctx);
90     if (err) {
91         debug_print ("gpgme_new failed: %s\n", gpgme_strerror (err));
92         goto leave;
93     }
94
95     err = gpgme_data_new_from_filepart (&cipher, NULL, fp,
96                                         partinfo->fpos, partinfo->size);
97     if (err) {
98         debug_print ("gpgme_data_new_from_filepart failed: %s\n",
99                      gpgme_strerror (err));
100         goto leave;
101     }
102
103     err = gpgme_data_new (&plain);
104     if (err) {
105         debug_print ("gpgme_new failed: %s\n", gpgme_strerror (err));
106         goto leave;
107     }
108
109     if (!getenv("GPG_AGENT_INFO")) {
110         info.c = ctx;
111         gpgme_set_passphrase_cb (ctx, gpgmegtk_passphrase_cb, &info);
112     } 
113
114     err = gpgme_op_decrypt (ctx, cipher, plain);
115
116 leave:
117     gpgme_data_release (cipher);
118     if (err) {
119         gpgmegtk_free_passphrase();
120         debug_print ("decryption failed: %s\n", gpgme_strerror (err));
121         gpgme_data_release (plain);
122         plain = NULL;
123     }
124     else
125         debug_print ("decryption succeeded\n");
126
127     gpgme_release (ctx);
128     return plain;
129 }
130
131 static int
132 headerp(char *p, char **names)
133 {
134     int i, c;
135     char *p2;
136
137     p2 = strchr(p, ':');
138     if(!p2 || p == p2) {
139         return 0;
140     }
141     if(p2[-1] == ' ' || p2[-1] == '\t') {
142         return 0;
143     }
144
145     if(!names[0])
146         return 1;  
147
148     c = *p2;
149     *p2 = 0;
150     for(i = 0 ; names[i] != NULL; i++) {
151         if(!gpg_name_cmp (names[i], p))
152             break;
153     }
154     *p2 = c;
155
156     return names[i] != NULL;
157 }
158
159 MimeInfo * pgptext_find_signature (MimeInfo *mimeinfo)
160 {
161 }
162
163 gboolean pgptext_has_signature (MimeInfo *mimeinfo)
164 {
165         /*
166          * check for the following strings:
167          *   -----BEGIN PGP SIGNED MESSAGE-----
168          *   ----- ????
169          *   -----BEGIN PGP SIGNATURE-----
170          *   -----END PGP SIGNATURE-----
171          */
172         
173         return 0;
174 }
175
176 void pgptext_check_signature (MimeInfo *mimeinfo, FILE *fp)
177 {
178 }
179
180 int pgptext_is_encrypted (MimeInfo *mimeinfo, MsgInfo *msginfo)
181 {
182         FILE *fp;
183         gchar *file, *tmpchk;
184         gchar buf[BUFFSIZE];
185         gboolean has_begin_pgp_msg = FALSE;
186         gboolean has_end_pgp_msg = FALSE;
187         gchar *check_begin_pgp_msg = "-----BEGIN PGP MESSAGE-----\n";
188         gchar *check_end_pgp_msg = "-----END PGP MESSAGE-----\n";
189         
190         g_return_if_fail(msginfo != NULL);
191         
192         if (!mimeinfo)
193                 return 0;
194         
195         if ((fp = procmsg_open_message(msginfo)) == NULL) return;
196         mimeinfo = procmime_scan_mime_header(fp);
197         fclose(fp);
198         if (!mimeinfo) return;
199
200         file = procmsg_get_message_file_path(msginfo);
201         g_return_if_fail(file != NULL);
202
203         if (mimeinfo->mime_type != MIME_TEXT) {
204                 if ((fp = fopen(file, "rb")) == NULL) {
205                         FILE_OP_ERROR(file, "fopen");
206                         return;
207                 }
208                 /* skip headers */
209                 if (mimeinfo->mime_type == MIME_MULTIPART) {
210                         if (fseek(fp, mimeinfo->fpos, SEEK_SET) < 0)
211                         perror("fseek");
212                         while (fgets(buf, sizeof(buf), fp) != NULL)
213                                 if (buf[0] == '\r' || buf[0] == '\n') break;
214                 }
215                 /* now check for a pgptext encrypted message */
216                 while (fgets(buf, sizeof(buf), fp) != NULL) {
217                         tmpchk = g_strnfill(sizeof(buf), '\n');
218                         memmove(tmpchk, &buf, sizeof(buf));
219                         
220                         if (strstr(tmpchk, check_begin_pgp_msg) != NULL)
221                                 has_begin_pgp_msg = TRUE;
222                         if (strstr(tmpchk, check_end_pgp_msg) != NULL)
223                                 has_end_pgp_msg = TRUE;
224                         
225                         g_free(tmpchk);
226                 }
227                 fclose(fp);
228         } else {
229                 if ((fp = fopen(file, "rb")) == NULL) {
230                         FILE_OP_ERROR(file, "fopen");
231                         return;
232                 }
233                 /* skip headers */
234                 if (fseek(fp, mimeinfo->fpos, SEEK_SET) < 0)
235                 perror("fseek");
236                 while (fgets(buf, sizeof(buf), fp) != NULL)
237                         if (buf[0] == '\r' || buf[0] == '\n') break;
238                 
239                 /* now check for a pgptext encrypted message */
240                 while (fgets(buf, sizeof(buf), fp) != NULL) {
241                         tmpchk = g_strnfill(sizeof(buf), '\n');
242                         memmove(tmpchk, &buf, sizeof(buf));
243                         
244                         if (strstr(tmpchk, check_begin_pgp_msg) != NULL)
245                                 has_begin_pgp_msg = TRUE;
246                         if (strstr(tmpchk, check_end_pgp_msg) != NULL)
247                                 has_end_pgp_msg = TRUE;
248                         
249                         g_free(tmpchk);
250                 }
251                 fclose(fp);
252         }
253         
254         g_free(file);   
255         
256         /* do we have a proper message? */
257         if (has_begin_pgp_msg && has_end_pgp_msg)
258                 return 1;
259         else
260                 return 0;
261 }
262
263 void pgptext_decrypt_message (MsgInfo *msginfo, MimeInfo *mimeinfo, FILE *fp)
264 {
265     static int id;
266     MimeInfo *partinfo;
267     int n, found;
268     int ver_okay=0;
269     char *fname;
270     GpgmeData plain;
271     FILE *dstfp;
272     size_t nread;
273     char buf[BUFFSIZE];
274     GpgmeError err;
275
276     g_return_if_fail (mimeinfo->mime_type == MIME_TEXT);
277
278     debug_print ("text/plain with pgptext encountered\n");
279
280     partinfo = procmime_scan_message(msginfo);
281                 
282     /* skip headers */
283     if (fseek(fp, partinfo->fpos, SEEK_SET) < 0)
284         perror("fseek");
285     while (fgets(buf, sizeof(buf), fp) != NULL) {
286                                 partinfo->fpos = partinfo->fpos + strlen(buf);
287         if (buf[0] == '\r' || buf[0] == '\n') break;
288                 }
289     /* get size */
290     while (fgets(buf, sizeof(buf), fp) != NULL)
291                                 partinfo->size = partinfo->size + strlen(buf);
292                 
293     plain = pgptext_decrypt (partinfo, fp);
294     if (!plain) {
295         msginfo->decryption_failed = 1;
296         return;
297     }
298     
299     fname = g_strdup_printf("%s%cplaintext.%08x",
300                             get_mime_tmp_dir(), G_DIR_SEPARATOR, ++id);
301
302     if ((dstfp = fopen(fname, "wb")) == NULL) {
303         FILE_OP_ERROR(fname, "fopen");
304         g_free(fname);
305         msginfo->decryption_failed = 1;
306         return;
307     }
308
309     /* write the orginal header to the new file */
310     if (fseek(fp, mimeinfo->fpos, SEEK_SET) < 0)
311         perror("fseek");
312
313     while (fgets(buf, sizeof(buf), fp)) {
314         if (headerp (buf, content_names))
315             continue;
316         if (buf[0] == '\r' || buf[0] == '\n')
317             break;
318         fputs (buf, dstfp);
319     }
320                 
321     err = gpgme_data_rewind (plain);
322     if (err)
323         debug_print ("gpgme_data_rewind failed: %s\n", gpgme_strerror (err));
324
325                 /* insert blank line to avoid some trouble... */
326                 fputs ("\n", dstfp);
327                 
328     while (!(err = gpgme_data_read (plain, buf, sizeof(buf), &nread))) {
329         fwrite (buf, nread, 1, dstfp);
330     }
331
332     if (err != GPGME_EOF) {
333         debug_print ("gpgme_data_read failed: %s\n", gpgme_strerror (err));
334     }
335
336     fclose (dstfp);
337
338     msginfo->plaintext_file = fname;
339     msginfo->decryption_failed = 0;
340
341 }
342
343 int pgptext_encrypt (const char *file, GSList *recp_list)
344 {
345 }
346
347 int pgptext_sign (const char *file, PrefsAccount *ac)
348 {
349 }
350
351 #endif  /* USE_GPGME */
352