a82139afa8c53cd1496d8c3f3c44b6d12bf80acf
[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 "common/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 /* stolen from rfc2015.c */
62 static int
63 gpg_name_cmp(const char *a, const char *b)
64 {
65     for( ; *a && *b; a++, b++) {
66         if(*a != *b
67            && toupper(*(unsigned char *)a) != toupper(*(unsigned char *)b))
68             return 1;
69     }
70
71     return *a != *b;
72 }
73
74 static GpgmeData
75 pgptext_decrypt (MimeInfo *partinfo, FILE *fp)
76 {
77     GpgmeCtx ctx = NULL;
78     GpgmeError err;
79     GpgmeData cipher = NULL, plain = NULL;
80     struct passphrase_cb_info_s info;
81
82     memset (&info, 0, sizeof info);
83
84     err = gpgme_new (&ctx);
85     if (err) {
86         debug_print ("gpgme_new failed: %s\n", gpgme_strerror (err));
87         goto leave;
88     }
89
90     err = gpgme_data_new_from_filepart (&cipher, NULL, fp,
91                                         partinfo->fpos, partinfo->size);
92     if (err) {
93         debug_print ("gpgme_data_new_from_filepart failed: %s\n",
94                      gpgme_strerror (err));
95         goto leave;
96     }
97
98     err = gpgme_data_new (&plain);
99     if (err) {
100         debug_print ("gpgme_new failed: %s\n", gpgme_strerror (err));
101         goto leave;
102     }
103
104     if (!getenv("GPG_AGENT_INFO")) {
105         info.c = ctx;
106         gpgme_set_passphrase_cb (ctx, gpgmegtk_passphrase_cb, (void *)&info);
107     } 
108
109     err = gpgme_op_decrypt (ctx, cipher, plain);
110
111 leave:
112     gpgme_data_release (cipher);
113     if (err) {
114         gpgmegtk_free_passphrase();
115         debug_print ("decryption failed: %s\n", gpgme_strerror (err));
116         gpgme_data_release (plain);
117         plain = NULL;
118     }
119     else
120         debug_print ("decryption succeeded\n");
121
122     gpgme_release (ctx);
123     return plain;
124 }
125
126 static int
127 headerp(char *p, char **names)
128 {
129     int i, c;
130     char *p2;
131
132     p2 = strchr(p, ':');
133     if(!p2 || p == p2) {
134         return 0;
135     }
136     if(p2[-1] == ' ' || p2[-1] == '\t') {
137         return 0;
138     }
139
140     if(!names[0])
141         return 1;  
142
143     c = *p2;
144     *p2 = 0;
145     for(i = 0 ; names[i] != NULL; i++) {
146         if(!gpg_name_cmp (names[i], p))
147             break;
148     }
149     *p2 = c;
150
151     return names[i] != NULL;
152 }
153
154 MimeInfo * pgptext_find_signature (MimeInfo *mimeinfo)
155 {
156         return NULL;
157 }
158
159 gboolean pgptext_has_signature (MimeInfo *mimeinfo)
160 {
161         /*
162          * check for the following strings:
163          *   -----BEGIN PGP SIGNED MESSAGE-----
164          *   ----- ????
165          *   -----BEGIN PGP SIGNATURE-----
166          *   -----END PGP SIGNATURE-----
167          */
168         
169         return 0;
170 }
171
172 void pgptext_check_signature (MimeInfo *mimeinfo, FILE *fp)
173 {
174 }
175
176 int pgptext_is_encrypted (MimeInfo *mimeinfo, MsgInfo *msginfo)
177 {
178         FILE *fp;
179         gchar *file, *tmpchk;
180         gchar buf[BUFFSIZE];
181         gboolean has_begin_pgp_msg = FALSE;
182         gboolean has_end_pgp_msg = FALSE;
183         gchar *check_begin_pgp_msg = "-----BEGIN PGP MESSAGE-----\n";
184         gchar *check_end_pgp_msg = "-----END PGP MESSAGE-----\n";
185         
186         g_return_val_if_fail(msginfo != NULL, 0);
187         
188         if (!mimeinfo)
189                 return 0;
190         
191         if ((fp = procmsg_open_message(msginfo)) == NULL) return 0;
192         mimeinfo = procmime_scan_mime_header(fp);
193         fclose(fp);
194         if (!mimeinfo) return 0;
195
196         file = procmsg_get_message_file_path(msginfo);
197         g_return_val_if_fail(file != NULL, 0);
198
199         if (mimeinfo->mime_type != MIME_TEXT) {
200                 if ((fp = fopen(file, "rb")) == NULL) {
201                         FILE_OP_ERROR(file, "fopen");
202                         g_free(file);
203                         return 0;
204                 }
205                 /* skip headers */
206                 if (mimeinfo->mime_type == MIME_MULTIPART) {
207                         if (fseek(fp, mimeinfo->fpos, SEEK_SET) < 0)
208                         perror("fseek");
209                         while (fgets(buf, sizeof(buf), fp) != NULL)
210                                 if (buf[0] == '\r' || buf[0] == '\n') break;
211                 }
212                 /* now check for a pgptext encrypted message */
213                 while (fgets(buf, sizeof(buf), fp) != NULL) {
214                         tmpchk = g_strnfill(sizeof(buf), '\n');
215                         memmove(tmpchk, &buf, sizeof(buf));
216                         
217                         if (strstr(tmpchk, check_begin_pgp_msg) != NULL)
218                                 has_begin_pgp_msg = TRUE;
219                         if (strstr(tmpchk, check_end_pgp_msg) != NULL)
220                                 has_end_pgp_msg = TRUE;
221                         
222                         g_free(tmpchk);
223                 }
224                 fclose(fp);
225         } else {
226                 if ((fp = fopen(file, "rb")) == NULL) {
227                         FILE_OP_ERROR(file, "fopen");
228                         g_free(file);
229                         return 0;
230                 }
231                 /* skip headers */
232                 if (fseek(fp, mimeinfo->fpos, SEEK_SET) < 0)
233                 perror("fseek");
234                 while (fgets(buf, sizeof(buf), fp) != NULL)
235                         if (buf[0] == '\r' || buf[0] == '\n') break;
236                 
237                 /* now check for a pgptext encrypted message */
238                 while (fgets(buf, sizeof(buf), fp) != NULL) {
239                         tmpchk = g_strnfill(sizeof(buf), '\n');
240                         memmove(tmpchk, &buf, sizeof(buf));
241                         
242                         if (strstr(tmpchk, check_begin_pgp_msg) != NULL)
243                                 has_begin_pgp_msg = TRUE;
244                         if (strstr(tmpchk, check_end_pgp_msg) != NULL)
245                                 has_end_pgp_msg = TRUE;
246                         
247                         g_free(tmpchk);
248                 }
249                 fclose(fp);
250         }
251         
252         g_free(file);   
253         
254         /* do we have a proper message? */
255         if (has_begin_pgp_msg && has_end_pgp_msg)
256                 return 1;
257         else
258                 return 0;
259 }
260
261 void pgptext_decrypt_message (MsgInfo *msginfo, MimeInfo *mimeinfo, FILE *fp)
262 {
263     static int id;
264     MimeInfo *partinfo;
265     char *fname;
266     GpgmeData plain;
267     FILE *dstfp;
268     size_t nread;
269     char buf[BUFFSIZE];
270     GpgmeError err;
271
272     g_return_if_fail (mimeinfo->mime_type == MIME_TEXT);
273
274     debug_print ("text/plain with pgptext encountered\n");
275
276     partinfo = procmime_scan_message(msginfo);
277                 
278     /* skip headers */
279     if (fseek(fp, partinfo->fpos, SEEK_SET) < 0)
280         perror("fseek");
281     while (fgets(buf, sizeof(buf), fp) != NULL) {
282                                 partinfo->fpos = partinfo->fpos + strlen(buf);
283         if (buf[0] == '\r' || buf[0] == '\n') break;
284                 }
285     /* get size */
286     while (fgets(buf, sizeof(buf), fp) != NULL)
287                                 partinfo->size = partinfo->size + strlen(buf);
288                 
289     plain = pgptext_decrypt (partinfo, fp);
290     if (!plain) {
291         msginfo->decryption_failed = 1;
292         return;
293     }
294     
295     fname = g_strdup_printf("%s%cplaintext.%08x",
296                             get_mime_tmp_dir(), G_DIR_SEPARATOR, ++id);
297
298     if ((dstfp = fopen(fname, "wb")) == NULL) {
299         FILE_OP_ERROR(fname, "fopen");
300         g_free(fname);
301         msginfo->decryption_failed = 1;
302         return;
303     }
304
305     /* write the orginal header to the new file */
306     if (fseek(fp, mimeinfo->fpos, SEEK_SET) < 0)
307         perror("fseek");
308
309     while (fgets(buf, sizeof(buf), fp)) {
310         if (headerp (buf, content_names))
311             continue;
312         if (buf[0] == '\r' || buf[0] == '\n')
313             break;
314         fputs (buf, dstfp);
315     }
316                 
317     err = gpgme_data_rewind (plain);
318     if (err)
319         debug_print ("gpgme_data_rewind failed: %s\n", gpgme_strerror (err));
320
321                 /* insert blank line to avoid some trouble... */
322                 fputs ("\n", dstfp);
323                 
324     while (!(err = gpgme_data_read (plain, buf, sizeof(buf), &nread))) {
325         fwrite (buf, nread, 1, dstfp);
326     }
327
328     if (err != GPGME_EOF) {
329         debug_print ("gpgme_data_read failed: %s\n", gpgme_strerror (err));
330     }
331
332     fclose (dstfp);
333
334     msginfo->plaintext_file = fname;
335     msginfo->decryption_failed = 0;
336
337 }
338
339 int pgptext_encrypt (const char *file, GSList *recp_list)
340 {
341         return 0;
342 }
343
344 int pgptext_sign (const char *file, PrefsAccount *ac)
345 {
346         return 0;
347 }
348
349 #endif  /* USE_GPGME */
350