Rocco Rutte:
[apps/madmutt.git] / pgp.c
1 /*
2  * Copyright notice from original mutt:
3  * Copyright (C) 1996,1997 Michael R. Elkins <me@mutt.org>
4  * Copyright (C) 1998,1999 Thomas Roessler <roessler@does-not-exist.org>
5  * Copyright (C) 2004 g10 Code GmbH
6  *
7  * This file is part of mutt-ng, see http://www.muttng.org/.
8  * It's licensed under the GNU General Public License,
9  * please see the file GPL in the top level source directory.
10  */
11
12 /*
13  * This file contains all of the PGP routines necessary to sign, encrypt,
14  * verify and decrypt PGP messages in either the new PGP/MIME format, or
15  * in the older Application/Pgp format.  It also contains some code to
16  * cache the user's passphrase for repeat use when decrypting or signing
17  * a message.
18  */
19
20 #if HAVE_CONFIG_H
21 # include "config.h"
22 #endif
23
24 #include "mutt.h"
25 #include "enter.h"
26 #include "ascii.h"
27 #include "handler.h"
28 #include "mutt_curses.h"
29 #include "pgp.h"
30 #include "mime.h"
31 #include "copy.h"
32 #include "attach.h"
33
34 #include "lib/mem.h"
35 #include "lib/intl.h"
36 #include "lib/str.h"
37 #include "lib/debug.h"
38
39 #include <sys/wait.h>
40 #include <string.h>
41 #include <stdlib.h>
42 #include <unistd.h>
43 #include <sys/stat.h>
44 #include <errno.h>
45 #include <ctype.h>
46
47 #ifdef HAVE_LOCALE_H
48 #include <locale.h>
49 #endif
50
51 #ifdef HAVE_SYS_TIME_H
52 # include <sys/time.h>
53 #endif
54
55 #ifdef HAVE_SYS_RESOURCE_H
56 # include <sys/resource.h>
57 #endif
58
59 #ifdef CRYPT_BACKEND_CLASSIC_PGP
60
61 #include "mutt_crypt.h"
62 #include "mutt_menu.h"
63
64
65 char PgpPass[LONG_STRING];
66 time_t PgpExptime = 0;          /* when does the cached passphrase expire? */
67
68 void pgp_void_passphrase (void)
69 {
70   memset (PgpPass, 0, sizeof (PgpPass));
71   PgpExptime = 0;
72 }
73
74 int pgp_valid_passphrase (void)
75 {
76   time_t now = time (NULL);
77
78   if (pgp_use_gpg_agent ()) {
79     *PgpPass = 0;
80     return 1;                   /* handled by gpg-agent */
81   }
82
83   if (now < PgpExptime)
84     /* Use cached copy.  */
85     return 1;
86
87   pgp_void_passphrase ();
88
89   if (mutt_get_field_unbuffered (_("Enter PGP passphrase:"), PgpPass,
90                                  sizeof (PgpPass), M_PASS) == 0) {
91     PgpExptime = time (NULL) + PgpTimeout;
92     return (1);
93   }
94   else
95     PgpExptime = 0;
96
97   return 0;
98 }
99
100 void pgp_forget_passphrase (void)
101 {
102   pgp_void_passphrase ();
103   mutt_message _("PGP passphrase forgotten.");
104 }
105
106 int pgp_use_gpg_agent (void)
107 {
108   return option (OPTUSEGPGAGENT) && getenv ("GPG_TTY")
109     && getenv ("GPG_AGENT_INFO");
110 }
111
112 char *pgp_keyid (pgp_key_t k)
113 {
114   if ((k->flags & KEYFLAG_SUBKEY) && k->parent && option (OPTPGPIGNORESUB))
115     k = k->parent;
116
117   return _pgp_keyid (k);
118 }
119
120 char *_pgp_keyid (pgp_key_t k)
121 {
122   if (option (OPTPGPLONGIDS))
123     return k->keyid;
124   else
125     return (k->keyid + 8);
126 }
127
128 /* ----------------------------------------------------------------------------
129  * Routines for handing PGP input.
130  */
131
132
133
134 /* Copy PGP output messages and look for signs of a good signature */
135
136 static int pgp_copy_checksig (FILE * fpin, FILE * fpout)
137 {
138   int rv = -1;
139
140   if (PgpGoodSign.pattern) {
141     char *line = NULL;
142     int lineno = 0;
143     size_t linelen;
144
145     while ((line = mutt_read_line (line, &linelen, fpin, &lineno)) != NULL) {
146       if (regexec (PgpGoodSign.rx, line, 0, NULL, 0) == 0) {
147         debug_print (2, ("\"%s\" matches regexp.\n", line));
148         rv = 0;
149       }
150       else
151         debug_print (2, ("\"%s\" doesn't match regexp.\n", line));
152
153       if (strncmp (line, "[GNUPG:] ", 9) == 0)
154         continue;
155       fputs (line, fpout);
156       fputc ('\n', fpout);
157     }
158     mem_free (&line);
159   }
160   else {
161     debug_print (2, ("No pattern.\n"));
162     mutt_copy_stream (fpin, fpout);
163     rv = 1;
164   }
165
166   return rv;
167 }
168
169 /* 
170  * Copy a clearsigned message, and strip the signature and PGP's
171  * dash-escaping.
172  * 
173  * XXX - charset handling: We assume that it is safe to do
174  * character set decoding first, dash decoding second here, while
175  * we do it the other way around in the main handler.
176  * 
177  * (Note that we aren't worse than Outlook &c in this, and also
178  * note that we can successfully handle anything produced by any
179  * existing versions of mutt.) 
180  */
181
182 static void pgp_copy_clearsigned (FILE * fpin, STATE * s, char *charset)
183 {
184   char buf[HUGE_STRING];
185   short complete, armor_header;
186
187   FGETCONV *fc;
188
189   rewind (fpin);
190
191   fc = fgetconv_open (fpin, charset, Charset, M_ICONV_HOOK_FROM);
192
193   for (complete = 1, armor_header = 1;
194        fgetconvs (buf, sizeof (buf), fc) != NULL;
195        complete = strchr (buf, '\n') != NULL) {
196     if (!complete) {
197       if (!armor_header)
198         state_puts (buf, s);
199       continue;
200     }
201
202     if (str_cmp (buf, "-----BEGIN PGP SIGNATURE-----\n") == 0)
203       break;
204
205     if (armor_header) {
206       char *p = str_skip_initws (buf);
207
208       if (*p == '\0')
209         armor_header = 0;
210       continue;
211     }
212
213     if (s->prefix)
214       state_puts (s->prefix, s);
215
216     if (buf[0] == '-' && buf[1] == ' ')
217       state_puts (buf + 2, s);
218     else
219       state_puts (buf, s);
220   }
221
222   fgetconv_close (&fc);
223 }
224
225
226 /* Support for the Application/PGP Content Type. */
227
228 int pgp_application_pgp_handler (BODY * m, STATE * s)
229 {
230   int needpass = -1, pgp_keyblock = 0;
231   int c = 1;
232   int clearsign = 0, rv, rc;
233   long start_pos = 0;
234   long bytes, last_pos, offset;
235   char buf[HUGE_STRING];
236   char outfile[_POSIX_PATH_MAX];
237   char tmpfname[_POSIX_PATH_MAX];
238   FILE *pgpout = NULL, *pgpin = NULL, *pgperr = NULL;
239   FILE *tmpfp = NULL;
240   pid_t thepid;
241
242   short maybe_goodsig = 1;
243   short have_any_sigs = 0;
244
245   char body_charset[STRING];
246
247   mutt_get_body_charset (body_charset, sizeof (body_charset), m);
248
249   rc = 0;                       /* silence false compiler warning if (s->flags & M_DISPLAY) */
250
251   fseek (s->fpin, m->offset, 0);
252   last_pos = m->offset;
253
254   for (bytes = m->length; bytes > 0;) {
255     if (fgets (buf, sizeof (buf), s->fpin) == NULL)
256       break;
257
258     offset = ftell (s->fpin);
259     bytes -= (offset - last_pos);       /* don't rely on str_len(buf) */
260     last_pos = offset;
261
262     if (str_ncmp ("-----BEGIN PGP ", buf, 15) == 0) {
263       clearsign = 0;
264       start_pos = last_pos;
265
266       if (str_cmp ("MESSAGE-----\n", buf + 15) == 0)
267         needpass = 1;
268       else if (str_cmp ("SIGNED MESSAGE-----\n", buf + 15) == 0) {
269         clearsign = 1;
270         needpass = 0;
271       }
272       else if (!option (OPTDONTHANDLEPGPKEYS) &&
273                str_cmp ("PUBLIC KEY BLOCK-----\n", buf + 15) == 0) {
274         needpass = 0;
275         pgp_keyblock = 1;
276       }
277       else {
278         /* XXX - we may wish to recode here */
279         if (s->prefix)
280           state_puts (s->prefix, s);
281         state_puts (buf, s);
282         continue;
283       }
284
285       have_any_sigs = have_any_sigs || (clearsign && (s->flags & M_VERIFY));
286
287       /* Copy PGP material to temporary file */
288       mutt_mktemp (tmpfname);
289       if ((tmpfp = safe_fopen (tmpfname, "w+")) == NULL) {
290         mutt_perror (tmpfname);
291         return (-1);
292       }
293
294       fputs (buf, tmpfp);
295       while (bytes > 0 && fgets (buf, sizeof (buf) - 1, s->fpin) != NULL) {
296         offset = ftell (s->fpin);
297         bytes -= (offset - last_pos);   /* don't rely on str_len(buf) */
298         last_pos = offset;
299
300         fputs (buf, tmpfp);
301
302         if ((needpass
303              && str_cmp ("-----END PGP MESSAGE-----\n", buf) == 0)
304             || (!needpass
305                 && (str_cmp ("-----END PGP SIGNATURE-----\n", buf) == 0
306                     || str_cmp ("-----END PGP PUBLIC KEY BLOCK-----\n",
307                                     buf) == 0)))
308           break;
309       }
310
311       /* leave tmpfp open in case we still need it - but flush it! */
312       fflush (tmpfp);
313
314
315       /* Invoke PGP if needed */
316       if (!clearsign || (s->flags & M_VERIFY)) {
317         mutt_mktemp (outfile);
318         if ((pgpout = safe_fopen (outfile, "w+")) == NULL) {
319           mutt_perror (tmpfname);
320           return (-1);
321         }
322
323         if ((thepid = pgp_invoke_decode (&pgpin, NULL, &pgperr, -1,
324                                          fileno (pgpout), -1, tmpfname,
325                                          needpass)) == -1) {
326           safe_fclose (&pgpout);
327           maybe_goodsig = 0;
328           pgpin = NULL;
329           pgperr = NULL;
330           state_attach_puts (_
331                              ("[-- Error: unable to create PGP subprocess! --]\n"),
332                              s);
333         }
334         else {                  /* PGP started successfully */
335
336           if (needpass) {
337             if (!pgp_valid_passphrase ())
338               pgp_void_passphrase ();
339             if (pgp_use_gpg_agent ())
340               *PgpPass = 0;
341             fprintf (pgpin, "%s\n", PgpPass);
342           }
343
344           safe_fclose (&pgpin);
345
346           if (s->flags & M_DISPLAY) {
347             crypt_current_time (s, "PGP");
348             rc = pgp_copy_checksig (pgperr, s->fpout);
349           }
350
351           safe_fclose (&pgperr);
352           rv = mutt_wait_filter (thepid);
353
354           if (s->flags & M_DISPLAY) {
355             if (rc == 0)
356               have_any_sigs = 1;
357
358             /*
359              * Sig is bad if
360              * gpg_good_sign-pattern did not match || pgp_decode_command returned not 0
361              * Sig _is_ correct if
362              * gpg_good_sign="" && pgp_decode_command returned 0
363              */
364             if (rc == -1 || rv)
365               maybe_goodsig = 0;
366
367             state_attach_puts (_("[-- End of PGP output --]\n\n"), s);
368           }
369         }
370
371         /* treat empty result as sign of failure */
372         if (pgpout) {
373           rewind (pgpout);
374           c = fgetc (pgpout);
375           ungetc (c, pgpout);
376         }
377         if (!clearsign && (!pgpout || c == EOF)) {
378             mutt_error _("Could not decrypt PGP message");
379             mutt_sleep (1);
380             pgp_void_passphrase ();
381             rc = -1;
382             goto out;
383         }
384       }
385
386       /*
387        * Now, copy cleartext to the screen.  NOTE - we expect that PGP
388        * outputs utf-8 cleartext.  This may not always be true, but it 
389        * seems to be a reasonable guess.
390        */
391
392       if (s->flags & M_DISPLAY) {
393         if (needpass)
394           state_attach_puts (_("[-- BEGIN PGP MESSAGE --]\n\n"), s);
395         else if (pgp_keyblock)
396           state_attach_puts (_("[-- BEGIN PGP PUBLIC KEY BLOCK --]\n"), s);
397         else
398           state_attach_puts (_("[-- BEGIN PGP SIGNED MESSAGE --]\n\n"), s);
399       }
400
401       if (clearsign) {
402         rewind (tmpfp);
403         if (tmpfp)
404           pgp_copy_clearsigned (tmpfp, s, body_charset);
405       }
406       else if (pgpout) {
407         FGETCONV *fc;
408         int c;
409
410         rewind (pgpout);
411         state_set_prefix (s);
412         fc = fgetconv_open (pgpout, "utf-8", Charset, 0);
413         while ((c = fgetconv (fc)) != EOF)
414           state_prefix_putc (c, s);
415         fgetconv_close (&fc);
416       }
417
418       if (s->flags & M_DISPLAY) {
419         state_putc ('\n', s);
420         if (needpass) {
421           state_attach_puts (_("[-- END PGP MESSAGE --]\n"), s);
422           mutt_message _("PGP message successfully decrypted.");
423         }
424         else if (pgp_keyblock)
425           state_attach_puts (_("[-- END PGP PUBLIC KEY BLOCK --]\n"), s);
426         else
427           state_attach_puts (_("[-- END PGP SIGNED MESSAGE --]\n"), s);
428       }
429
430     }
431     else {
432       /* XXX - we may wish to recode here */
433       if (s->prefix)
434         state_puts (s->prefix, s);
435       state_puts (buf, s);
436     }
437   }
438
439   rc = 0;
440
441 out:
442   m->goodsig = (maybe_goodsig && have_any_sigs);
443
444   if (tmpfp) {
445     safe_fclose (&tmpfp);
446     mutt_unlink (tmpfname);
447   }
448   if (pgpout) {
449     safe_fclose (&pgpout);
450     mutt_unlink (outfile);
451   }
452
453   if (needpass == -1) {
454     state_attach_puts (_
455                        ("[-- Error: could not find beginning of PGP message! --]\n\n"),
456                        s);
457     return (-1);
458   }
459
460   return (rc);
461 }
462
463 static int pgp_check_traditional_one_body (FILE * fp, BODY * b,
464                                            int tagged_only)
465 {
466   char tempfile[_POSIX_PATH_MAX];
467   char buf[HUGE_STRING];
468   FILE *tfp;
469
470   short sgn = 0;
471   short enc = 0;
472   short key = 0;
473
474   if (b->type != TYPETEXT)
475     return 0;
476
477   if (tagged_only && !b->tagged)
478     return 0;
479
480   mutt_mktemp (tempfile);
481   if (mutt_decode_save_attachment (fp, b, tempfile, 0, 0) != 0) {
482     unlink (tempfile);
483     return 0;
484   }
485
486   if ((tfp = fopen (tempfile, "r")) == NULL) {
487     unlink (tempfile);
488     return 0;
489   }
490
491   while (fgets (buf, sizeof (buf), tfp)) {
492     if (str_ncmp ("-----BEGIN PGP ", buf, 15) == 0) {
493       if (str_cmp ("MESSAGE-----\n", buf + 15) == 0)
494         enc = 1;
495       else if (str_cmp ("SIGNED MESSAGE-----\n", buf + 15) == 0)
496         sgn = 1;
497       else if (str_cmp ("PUBLIC KEY BLOCK-----\n", buf + 15) == 0)
498         key = 1;
499     }
500   }
501   safe_fclose (&tfp);
502   unlink (tempfile);
503
504   if (!enc && !sgn && !key)
505     return 0;
506
507   /* fix the content type */
508
509   mutt_set_parameter ("format", "fixed", &b->parameter);
510   if (enc)
511     mutt_set_parameter ("x-action", "pgp-encrypted", &b->parameter);
512   else if (sgn)
513     mutt_set_parameter ("x-action", "pgp-signed", &b->parameter);
514   else if (key)
515     mutt_set_parameter ("x-action", "pgp-keys", &b->parameter);
516
517   return 1;
518 }
519
520 int pgp_check_traditional (FILE * fp, BODY * b, int tagged_only)
521 {
522   int rv = 0;
523   int r;
524
525   for (; b; b = b->next) {
526     if (is_multipart (b))
527       rv = pgp_check_traditional (fp, b->parts, tagged_only) || rv;
528     else if (b->type == TYPETEXT) {
529       if ((r = mutt_is_application_pgp (b)))
530         rv = rv || r;
531       else
532         rv = pgp_check_traditional_one_body (fp, b, tagged_only) || rv;
533     }
534   }
535
536   return rv;
537 }
538
539
540
541
542
543 int pgp_verify_one (BODY * sigbdy, STATE * s, const char *tempfile)
544 {
545   char sigfile[_POSIX_PATH_MAX], pgperrfile[_POSIX_PATH_MAX];
546   FILE *fp, *pgpout, *pgperr;
547   pid_t thepid;
548   int badsig = -1;
549   int rv;
550
551   snprintf (sigfile, sizeof (sigfile), "%s.asc", tempfile);
552
553   if (!(fp = safe_fopen (sigfile, "w"))) {
554     mutt_perror (sigfile);
555     return -1;
556   }
557
558   fseek (s->fpin, sigbdy->offset, 0);
559   mutt_copy_bytes (s->fpin, fp, sigbdy->length);
560   fclose (fp);
561
562   mutt_mktemp (pgperrfile);
563   if (!(pgperr = safe_fopen (pgperrfile, "w+"))) {
564     mutt_perror (pgperrfile);
565     unlink (sigfile);
566     return -1;
567   }
568
569   crypt_current_time (s, "PGP");
570
571   if ((thepid = pgp_invoke_verify (NULL, &pgpout, NULL,
572                                    -1, -1, fileno (pgperr),
573                                    tempfile, sigfile)) != -1) {
574     if (pgp_copy_checksig (pgpout, s->fpout) >= 0)
575       badsig = 0;
576
577
578     safe_fclose (&pgpout);
579     fflush (pgperr);
580     rewind (pgperr);
581
582     if (pgp_copy_checksig (pgperr, s->fpout) >= 0)
583       badsig = 0;
584
585     if ((rv = mutt_wait_filter (thepid)))
586       badsig = -1;
587
588     debug_print (1, ("mutt_wait_filter returned %d.\n", rv));
589   }
590
591   safe_fclose (&pgperr);
592
593   state_attach_puts (_("[-- End of PGP output --]\n\n"), s);
594
595   mutt_unlink (sigfile);
596   mutt_unlink (pgperrfile);
597
598   debug_print (1, ("returning %d.\n", badsig));
599
600   return badsig;
601 }
602
603
604 /* Extract pgp public keys from messages or attachments */
605
606 void pgp_extract_keys_from_messages (HEADER * h)
607 {
608   int i;
609   char tempfname[_POSIX_PATH_MAX];
610   FILE *fpout;
611
612   if (h) {
613     mutt_parse_mime_message (Context, h);
614     if (h->security & PGPENCRYPT && !pgp_valid_passphrase ())
615       return;
616   }
617
618   mutt_mktemp (tempfname);
619   if (!(fpout = safe_fopen (tempfname, "w"))) {
620     mutt_perror (tempfname);
621     return;
622   }
623
624   set_option (OPTDONTHANDLEPGPKEYS);
625
626   if (!h) {
627     for (i = 0; i < Context->vcount; i++) {
628       if (Context->hdrs[Context->v2r[i]]->tagged) {
629         mutt_parse_mime_message (Context, Context->hdrs[Context->v2r[i]]);
630         if (Context->hdrs[Context->v2r[i]]->security & PGPENCRYPT
631             && !pgp_valid_passphrase ()) {
632           fclose (fpout);
633           goto bailout;
634         }
635         mutt_copy_message (fpout, Context, Context->hdrs[Context->v2r[i]],
636                            M_CM_DECODE | M_CM_CHARCONV, 0);
637       }
638     }
639   }
640   else {
641     mutt_parse_mime_message (Context, h);
642     if (h->security & PGPENCRYPT && !pgp_valid_passphrase ()) {
643       fclose (fpout);
644       goto bailout;
645     }
646     mutt_copy_message (fpout, Context, h, M_CM_DECODE | M_CM_CHARCONV, 0);
647   }
648
649   fclose (fpout);
650   mutt_endwin (NULL);
651   pgp_invoke_import (tempfname);
652   mutt_any_key_to_continue (NULL);
653
654 bailout:
655
656   mutt_unlink (tempfname);
657   unset_option (OPTDONTHANDLEPGPKEYS);
658
659 }
660
661 static void pgp_extract_keys_from_attachment (FILE * fp, BODY * top)
662 {
663   STATE s;
664   FILE *tempfp;
665   char tempfname[_POSIX_PATH_MAX];
666
667   mutt_mktemp (tempfname);
668   if (!(tempfp = safe_fopen (tempfname, "w"))) {
669     mutt_perror (tempfname);
670     return;
671   }
672
673   memset (&s, 0, sizeof (STATE));
674
675   s.fpin = fp;
676   s.fpout = tempfp;
677
678   mutt_body_handler (top, &s);
679
680   fclose (tempfp);
681
682   pgp_invoke_import (tempfname);
683   mutt_any_key_to_continue (NULL);
684
685   mutt_unlink (tempfname);
686 }
687
688 void pgp_extract_keys_from_attachment_list (FILE * fp, int tag, BODY * top)
689 {
690   if (!fp) {
691     mutt_error _("Internal error. Inform <roessler@does-not-exist.org>.");
692
693     return;
694   }
695
696   mutt_endwin (NULL);
697   set_option (OPTDONTHANDLEPGPKEYS);
698
699   for (; top; top = top->next) {
700     if (!tag || top->tagged)
701       pgp_extract_keys_from_attachment (fp, top);
702
703     if (!tag)
704       break;
705   }
706
707   unset_option (OPTDONTHANDLEPGPKEYS);
708 }
709
710 BODY *pgp_decrypt_part (BODY * a, STATE * s, FILE * fpout, BODY * p)
711 {
712   char buf[LONG_STRING];
713   FILE *pgpin, *pgpout, *pgperr, *pgptmp;
714   struct stat info;
715   BODY *tattach;
716   int len;
717   char pgperrfile[_POSIX_PATH_MAX];
718   char pgptmpfile[_POSIX_PATH_MAX];
719   pid_t thepid;
720   int rv;
721
722   mutt_mktemp (pgperrfile);
723   if ((pgperr = safe_fopen (pgperrfile, "w+")) == NULL) {
724     mutt_perror (pgperrfile);
725     return NULL;
726   }
727   unlink (pgperrfile);
728
729   mutt_mktemp (pgptmpfile);
730   if ((pgptmp = safe_fopen (pgptmpfile, "w")) == NULL) {
731     mutt_perror (pgptmpfile);
732     fclose (pgperr);
733     return NULL;
734   }
735
736   /* Position the stream at the beginning of the body, and send the data to
737    * the temporary file.
738    */
739
740   fseek (s->fpin, a->offset, 0);
741   mutt_copy_bytes (s->fpin, pgptmp, a->length);
742   fclose (pgptmp);
743
744   if ((thepid = pgp_invoke_decrypt (&pgpin, &pgpout, NULL, -1, -1,
745                                     fileno (pgperr), pgptmpfile)) == -1) {
746     fclose (pgperr);
747     unlink (pgptmpfile);
748     if (s->flags & M_DISPLAY)
749       state_attach_puts (_
750                          ("[-- Error: could not create a PGP subprocess! --]\n\n"),
751                          s);
752     return (NULL);
753   }
754
755   /* send the PGP passphrase to the subprocess.  Never do this if the
756      agent is active, because this might lead to a passphrase send as
757      the message. */
758   if (!pgp_use_gpg_agent ())
759     fputs (PgpPass, pgpin);
760   fputc ('\n', pgpin);
761   fclose (pgpin);
762
763   /* Read the output from PGP, and make sure to change CRLF to LF, otherwise
764    * read_mime_header has a hard time parsing the message.
765    */
766   while (fgets (buf, sizeof (buf) - 1, pgpout) != NULL) {
767     len = str_len (buf);
768     if (len > 1 && buf[len - 2] == '\r')
769       strcpy (buf + len - 2, "\n");     /* __STRCPY_CHECKED__ */
770     fputs (buf, fpout);
771   }
772
773   fclose (pgpout);
774   rv = mutt_wait_filter (thepid);
775   mutt_unlink (pgptmpfile);
776
777   if (s->flags & M_DISPLAY) {
778     fflush (pgperr);
779     rewind (pgperr);
780     if (pgp_copy_checksig (pgperr, s->fpout) == 0 && !rv && p)
781       p->goodsig = 1;
782     else
783       p->goodsig = 0;
784     state_attach_puts (_("[-- End of PGP output --]\n\n"), s);
785   }
786   fclose (pgperr);
787
788   fflush (fpout);
789   rewind (fpout);
790
791   if (fgetc (fpout) == EOF) {
792     mutt_error (_("Decryption failed."));
793     pgp_void_passphrase ();
794     return NULL;
795   }
796
797   rewind (fpout);
798
799   if ((tattach = mutt_read_mime_header (fpout, 0)) != NULL) {
800     /*
801      * Need to set the length of this body part.
802      */
803     fstat (fileno (fpout), &info);
804     tattach->length = info.st_size - tattach->offset;
805
806     /* See if we need to recurse on this MIME part.  */
807
808     mutt_parse_part (fpout, tattach);
809   }
810
811   return (tattach);
812 }
813
814 int pgp_decrypt_mime (FILE * fpin, FILE ** fpout, BODY * b, BODY ** cur)
815 {
816   char tempfile[_POSIX_PATH_MAX];
817   STATE s;
818   BODY *p = b;
819
820   if (!mutt_is_multipart_encrypted (b))
821     return -1;
822
823   if (!b->parts || !b->parts->next)
824     return -1;
825
826   b = b->parts->next;
827
828   memset (&s, 0, sizeof (s));
829   s.fpin = fpin;
830   mutt_mktemp (tempfile);
831   if ((*fpout = safe_fopen (tempfile, "w+")) == NULL) {
832     mutt_perror (tempfile);
833     return (-1);
834   }
835   unlink (tempfile);
836
837   *cur = pgp_decrypt_part (b, &s, *fpout, p);
838
839   rewind (*fpout);
840
841   if (!*cur)
842     return -1;
843
844   return (0);
845 }
846
847 int pgp_encrypted_handler (BODY * a, STATE * s)
848 {
849   char tempfile[_POSIX_PATH_MAX];
850   FILE *fpout, *fpin;
851   BODY *tattach;
852   BODY *p = a;
853   int rc = 0;
854
855   a = a->parts;
856   if (!a || a->type != TYPEAPPLICATION || !a->subtype ||
857       ascii_strcasecmp ("pgp-encrypted", a->subtype) != 0 ||
858       !a->next || a->next->type != TYPEAPPLICATION || !a->next->subtype ||
859       ascii_strcasecmp ("octet-stream", a->next->subtype) != 0) {
860     if (s->flags & M_DISPLAY)
861       state_attach_puts (_("[-- Error: malformed PGP/MIME message! --]\n\n"),
862                          s);
863     return (-1);
864   }
865
866   /*
867    * Move forward to the application/pgp-encrypted body.
868    */
869   a = a->next;
870
871   mutt_mktemp (tempfile);
872   if ((fpout = safe_fopen (tempfile, "w+")) == NULL) {
873     if (s->flags & M_DISPLAY)
874       state_attach_puts (_
875                          ("[-- Error: could not create temporary file! --]\n"),
876                          s);
877     return (-1);
878   }
879
880   if (s->flags & M_DISPLAY)
881     crypt_current_time (s, "PGP");
882
883   if ((tattach = pgp_decrypt_part (a, s, fpout, p)) != NULL) {
884     if (s->flags & M_DISPLAY)
885       state_attach_puts (_
886                          ("[-- The following data is PGP/MIME encrypted --]\n\n"),
887                          s);
888
889     fpin = s->fpin;
890     s->fpin = fpout;
891     rc = mutt_body_handler (tattach, s);
892     s->fpin = fpin;
893
894     /* 
895      * if a multipart/signed is the _only_ sub-part of a
896      * multipart/encrypted, cache signature verification
897      * status.
898      *
899      */
900
901     if (mutt_is_multipart_signed (tattach) && !tattach->next)
902       p->goodsig |= tattach->goodsig;
903
904     if (s->flags & M_DISPLAY) {
905       state_puts ("\n", s);
906       state_attach_puts (_("[-- End of PGP/MIME encrypted data --]\n"), s);
907     }
908
909     mutt_free_body (&tattach);
910     /* clear 'Invoking...' message, since there's no error */
911     mutt_message _("PGP message successfully decrypted.");
912   } else {
913     mutt_error _("Could not decrypt PGP message");
914     pgp_void_passphrase ();
915     rc = -1;
916   }
917
918   fclose (fpout);
919   mutt_unlink (tempfile);
920
921   return (rc);
922 }
923
924 /* ----------------------------------------------------------------------------
925  * Routines for sending PGP/MIME messages.
926  */
927
928
929 BODY *pgp_sign_message (BODY * a)
930 {
931   BODY *t;
932   char buffer[LONG_STRING];
933   char sigfile[_POSIX_PATH_MAX], signedfile[_POSIX_PATH_MAX];
934   FILE *pgpin, *pgpout, *pgperr, *fp, *sfp;
935   int err = 0;
936   int empty = 1;
937   pid_t thepid;
938
939   convert_to_7bit (a);          /* Signed data _must_ be in 7-bit format. */
940
941   mutt_mktemp (sigfile);
942   if ((fp = safe_fopen (sigfile, "w")) == NULL) {
943     return (NULL);
944   }
945
946   mutt_mktemp (signedfile);
947   if ((sfp = safe_fopen (signedfile, "w")) == NULL) {
948     mutt_perror (signedfile);
949     fclose (fp);
950     unlink (sigfile);
951     return NULL;
952   }
953
954   mutt_write_mime_header (a, sfp);
955   fputc ('\n', sfp);
956   mutt_write_mime_body (a, sfp);
957   fclose (sfp);
958
959   if ((thepid = pgp_invoke_sign (&pgpin, &pgpout, &pgperr,
960                                  -1, -1, -1, signedfile)) == -1) {
961     mutt_perror (_("Can't open PGP subprocess!"));
962
963     fclose (fp);
964     unlink (sigfile);
965     unlink (signedfile);
966     return NULL;
967   }
968
969   if (!pgp_use_gpg_agent ())
970     fputs (PgpPass, pgpin);
971   fputc ('\n', pgpin);
972   fclose (pgpin);
973
974   /*
975    * Read back the PGP signature.  Also, change MESSAGE=>SIGNATURE as
976    * recommended for future releases of PGP.
977    */
978   while (fgets (buffer, sizeof (buffer) - 1, pgpout) != NULL) {
979     if (str_cmp ("-----BEGIN PGP MESSAGE-----\n", buffer) == 0)
980       fputs ("-----BEGIN PGP SIGNATURE-----\n", fp);
981     else if (str_cmp ("-----END PGP MESSAGE-----\n", buffer) == 0)
982       fputs ("-----END PGP SIGNATURE-----\n", fp);
983     else
984       fputs (buffer, fp);
985     empty = 0;                  /* got some output, so we're ok */
986   }
987
988   /* check for errors from PGP */
989   err = 0;
990   while (fgets (buffer, sizeof (buffer) - 1, pgperr) != NULL) {
991     err = 1;
992     fputs (buffer, stdout);
993   }
994
995   if (mutt_wait_filter (thepid) && option (OPTPGPCHECKEXIT))
996     empty = 1;
997
998   fclose (pgperr);
999   fclose (pgpout);
1000   unlink (signedfile);
1001
1002   if (fclose (fp) != 0) {
1003     mutt_perror ("fclose");
1004     unlink (sigfile);
1005     return (NULL);
1006   }
1007
1008   if (err) {
1009     pgp_void_passphrase ();
1010     mutt_any_key_to_continue (NULL);
1011   }
1012
1013   if (empty) {
1014     unlink (sigfile);
1015     return (NULL);              /* fatal error while signing */
1016   }
1017
1018   t = mutt_new_body ();
1019   t->type = TYPEMULTIPART;
1020   t->subtype = str_dup ("signed");
1021   t->encoding = ENC7BIT;
1022   t->use_disp = 0;
1023   t->disposition = DISPINLINE;
1024
1025   mutt_generate_boundary (&t->parameter);
1026   mutt_set_parameter ("protocol", "application/pgp-signature", &t->parameter);
1027   mutt_set_parameter ("micalg", pgp_micalg (sigfile), &t->parameter);
1028
1029   t->parts = a;
1030   a = t;
1031
1032   t->parts->next = mutt_new_body ();
1033   t = t->parts->next;
1034   t->type = TYPEAPPLICATION;
1035   t->subtype = str_dup ("pgp-signature");
1036   t->filename = str_dup (sigfile);
1037   t->use_disp = 0;
1038   t->disposition = DISPINLINE;
1039   t->encoding = ENC7BIT;
1040   t->unlink = 1;                /* ok to remove this file after sending. */
1041
1042   return (a);
1043 }
1044
1045 static short is_numerical_keyid (const char *s)
1046 {
1047   /* or should we require the "0x"? */
1048   if (strncmp (s, "0x", 2) == 0)
1049     s += 2;
1050   if (str_len (s) % 8)
1051     return 0;
1052   while (*s)
1053     if (strchr ("0123456789ABCDEFabcdef", *s++) == NULL)
1054       return 0;
1055
1056   return 1;
1057 }
1058
1059 /* This routine attempts to find the keyids of the recipients of a message.
1060  * It returns NULL if any of the keys can not be found.
1061  */
1062 char *pgp_findKeys (ADDRESS * to, ADDRESS * cc, ADDRESS * bcc)
1063 {
1064   char *keyID, *keylist = NULL, *t;
1065   size_t keylist_size = 0;
1066   size_t keylist_used = 0;
1067   ADDRESS *tmp = NULL, *addr = NULL;
1068   ADDRESS **last = &tmp;
1069   ADDRESS *p, *q;
1070   int i;
1071   pgp_key_t k_info = NULL, key = NULL;
1072
1073   const char *fqdn = mutt_fqdn (1);
1074
1075   for (i = 0; i < 3; i++) {
1076     switch (i) {
1077     case 0:
1078       p = to;
1079       break;
1080     case 1:
1081       p = cc;
1082       break;
1083     case 2:
1084       p = bcc;
1085       break;
1086     default:
1087       abort ();
1088     }
1089
1090     *last = rfc822_cpy_adr (p);
1091     while (*last)
1092       last = &((*last)->next);
1093   }
1094
1095   if (fqdn)
1096     rfc822_qualify (tmp, fqdn);
1097
1098   tmp = mutt_remove_duplicates (tmp);
1099
1100   for (p = tmp; p; p = p->next) {
1101     char buf[LONG_STRING];
1102
1103     q = p;
1104     k_info = NULL;
1105
1106     if ((keyID = mutt_crypt_hook (p)) != NULL) {
1107       int r;
1108
1109       snprintf (buf, sizeof (buf), _("Use keyID = \"%s\" for %s?"), keyID,
1110                 p->mailbox);
1111       if ((r = mutt_yesorno (buf, M_YES)) == M_YES) {
1112         if (is_numerical_keyid (keyID)) {
1113           if (strncmp (keyID, "0x", 2) == 0)
1114             keyID += 2;
1115           goto bypass_selection;        /* you don't see this. */
1116         }
1117
1118         /* check for e-mail address */
1119         if ((t = strchr (keyID, '@')) &&
1120             (addr = rfc822_parse_adrlist (NULL, keyID))) {
1121           if (fqdn)
1122             rfc822_qualify (addr, fqdn);
1123           q = addr;
1124         }
1125         else
1126           k_info = pgp_getkeybystr (keyID, KEYFLAG_CANENCRYPT, PGP_PUBRING);
1127       }
1128       else if (r == -1) {
1129         mem_free (&keylist);
1130         rfc822_free_address (&tmp);
1131         rfc822_free_address (&addr);
1132         return NULL;
1133       }
1134     }
1135
1136     if (k_info == NULL)
1137       pgp_invoke_getkeys (q);
1138
1139     if (k_info == NULL
1140         && (k_info =
1141             pgp_getkeybyaddr (q, KEYFLAG_CANENCRYPT, PGP_PUBRING)) == NULL) {
1142       snprintf (buf, sizeof (buf), _("Enter keyID for %s: "), q->mailbox);
1143
1144       if ((key = pgp_ask_for_key (buf, q->mailbox,
1145                                   KEYFLAG_CANENCRYPT, PGP_PUBRING)) == NULL) {
1146         mem_free (&keylist);
1147         rfc822_free_address (&tmp);
1148         rfc822_free_address (&addr);
1149         return NULL;
1150       }
1151     }
1152     else
1153       key = k_info;
1154
1155     keyID = pgp_keyid (key);
1156
1157   bypass_selection:
1158     keylist_size += str_len (keyID) + 4;
1159     mem_realloc (&keylist, keylist_size);
1160     sprintf (keylist + keylist_used, "%s0x%s", keylist_used ? " " : "", /* __SPRINTF_CHECKED__ */
1161              keyID);
1162     keylist_used = str_len (keylist);
1163
1164     pgp_free_key (&key);
1165     rfc822_free_address (&addr);
1166
1167   }
1168   rfc822_free_address (&tmp);
1169   return (keylist);
1170 }
1171
1172 /* Warning: "a" is no longer freed in this routine, you need
1173  * to free it later.  This is necessary for $fcc_attach. */
1174
1175 BODY *pgp_encrypt_message (BODY * a, char *keylist, int sign)
1176 {
1177   char buf[LONG_STRING];
1178   char tempfile[_POSIX_PATH_MAX], pgperrfile[_POSIX_PATH_MAX];
1179   char pgpinfile[_POSIX_PATH_MAX];
1180   FILE *pgpin, *pgperr, *fpout, *fptmp;
1181   BODY *t;
1182   int err = 0;
1183   int empty = 0;
1184   pid_t thepid;
1185
1186   mutt_mktemp (tempfile);
1187   if ((fpout = safe_fopen (tempfile, "w+")) == NULL) {
1188     mutt_perror (tempfile);
1189     return (NULL);
1190   }
1191
1192   mutt_mktemp (pgperrfile);
1193   if ((pgperr = safe_fopen (pgperrfile, "w+")) == NULL) {
1194     mutt_perror (pgperrfile);
1195     unlink (tempfile);
1196     fclose (fpout);
1197     return NULL;
1198   }
1199   unlink (pgperrfile);
1200
1201   mutt_mktemp (pgpinfile);
1202   if ((fptmp = safe_fopen (pgpinfile, "w")) == NULL) {
1203     mutt_perror (pgpinfile);
1204     unlink (tempfile);
1205     fclose (fpout);
1206     fclose (pgperr);
1207     return NULL;
1208   }
1209
1210   if (sign)
1211     convert_to_7bit (a);
1212
1213   mutt_write_mime_header (a, fptmp);
1214   fputc ('\n', fptmp);
1215   mutt_write_mime_body (a, fptmp);
1216   fclose (fptmp);
1217
1218   if ((thepid = pgp_invoke_encrypt (&pgpin, NULL, NULL, -1,
1219                                     fileno (fpout), fileno (pgperr),
1220                                     pgpinfile, keylist, sign)) == -1) {
1221     fclose (pgperr);
1222     unlink (pgpinfile);
1223     return (NULL);
1224   }
1225
1226   if (sign) {
1227     if (!pgp_use_gpg_agent ())
1228       fputs (PgpPass, pgpin);
1229     fputc ('\n', pgpin);
1230   }
1231   fclose (pgpin);
1232
1233   if (mutt_wait_filter (thepid) && option (OPTPGPCHECKEXIT))
1234     empty = 1;
1235
1236   unlink (pgpinfile);
1237
1238   fflush (fpout);
1239   rewind (fpout);
1240   if (!empty)
1241     empty = (fgetc (fpout) == EOF);
1242   fclose (fpout);
1243
1244   fflush (pgperr);
1245   rewind (pgperr);
1246   while (fgets (buf, sizeof (buf) - 1, pgperr) != NULL) {
1247     err = 1;
1248     fputs (buf, stdout);
1249   }
1250   fclose (pgperr);
1251
1252   /* pause if there is any error output from PGP */
1253   if (err)
1254     mutt_any_key_to_continue (NULL);
1255
1256   if (empty) {
1257     /* fatal error while trying to encrypt message */
1258     if (sign)
1259       pgp_void_passphrase (); /* just in case */
1260     unlink (tempfile);
1261     return (NULL);
1262   }
1263
1264   t = mutt_new_body ();
1265   t->type = TYPEMULTIPART;
1266   t->subtype = str_dup ("encrypted");
1267   t->encoding = ENC7BIT;
1268   t->use_disp = 0;
1269   t->disposition = DISPINLINE;
1270
1271   mutt_generate_boundary (&t->parameter);
1272   mutt_set_parameter ("protocol", "application/pgp-encrypted", &t->parameter);
1273
1274   t->parts = mutt_new_body ();
1275   t->parts->type = TYPEAPPLICATION;
1276   t->parts->subtype = str_dup ("pgp-encrypted");
1277   t->parts->encoding = ENC7BIT;
1278
1279   t->parts->next = mutt_new_body ();
1280   t->parts->next->type = TYPEAPPLICATION;
1281   t->parts->next->subtype = str_dup ("octet-stream");
1282   t->parts->next->encoding = ENC7BIT;
1283   t->parts->next->filename = str_dup (tempfile);
1284   t->parts->next->use_disp = 1;
1285   t->parts->next->disposition = DISPINLINE;
1286   t->parts->next->unlink = 1;   /* delete after sending the message */
1287   t->parts->next->d_filename = str_dup ("msg.asc"); /* non pgp/mime can save */
1288
1289   return (t);
1290 }
1291
1292 BODY *pgp_traditional_encryptsign (BODY * a, int flags, char *keylist)
1293 {
1294   BODY *b;
1295
1296   char pgpoutfile[_POSIX_PATH_MAX];
1297   char pgperrfile[_POSIX_PATH_MAX];
1298   char pgpinfile[_POSIX_PATH_MAX];
1299
1300   char body_charset[STRING];
1301   char *from_charset;
1302   const char *send_charset;
1303
1304   FILE *pgpout = NULL, *pgperr = NULL, *pgpin = NULL;
1305   FILE *fp;
1306
1307   int empty = 0;
1308   int err;
1309
1310   char buff[STRING];
1311
1312   pid_t thepid;
1313
1314   if (a->type != TYPETEXT)
1315     return NULL;
1316   if (ascii_strcasecmp (a->subtype, "plain"))
1317     return NULL;
1318
1319   if ((fp = fopen (a->filename, "r")) == NULL) {
1320     mutt_perror (a->filename);
1321     return NULL;
1322   }
1323
1324   mutt_mktemp (pgpinfile);
1325   if ((pgpin = safe_fopen (pgpinfile, "w")) == NULL) {
1326     mutt_perror (pgpinfile);
1327     fclose (fp);
1328     return NULL;
1329   }
1330
1331   /* The following code is really correct:  If noconv is set,
1332    * a's charset parameter contains the on-disk character set, and
1333    * we have to convert from that to utf-8.  If noconv is not set,
1334    * we have to convert from $charset to utf-8.
1335    */
1336
1337   mutt_get_body_charset (body_charset, sizeof (body_charset), a);
1338   if (a->noconv)
1339     from_charset = body_charset;
1340   else
1341     from_charset = Charset;
1342
1343   if (!mutt_is_us_ascii (body_charset)) {
1344     int c;
1345     FGETCONV *fc;
1346
1347     if (flags & ENCRYPT)
1348       send_charset = "us-ascii";
1349     else
1350       send_charset = "utf-8";
1351
1352     fc = fgetconv_open (fp, from_charset, "utf-8", M_ICONV_HOOK_FROM);
1353     while ((c = fgetconv (fc)) != EOF)
1354       fputc (c, pgpin);
1355
1356     fgetconv_close (&fc);
1357   }
1358   else {
1359     send_charset = "us-ascii";
1360     mutt_copy_stream (fp, pgpin);
1361   }
1362   safe_fclose (&fp);
1363   fclose (pgpin);
1364
1365   mutt_mktemp (pgpoutfile);
1366   mutt_mktemp (pgperrfile);
1367   if ((pgpout = safe_fopen (pgpoutfile, "w+")) == NULL ||
1368       (pgperr = safe_fopen (pgperrfile, "w+")) == NULL) {
1369     mutt_perror (pgpout ? pgperrfile : pgpoutfile);
1370     unlink (pgpinfile);
1371     if (pgpout) {
1372       fclose (pgpout);
1373       unlink (pgpoutfile);
1374     }
1375     return NULL;
1376   }
1377
1378   unlink (pgperrfile);
1379
1380   if ((thepid = pgp_invoke_traditional (&pgpin, NULL, NULL,
1381                                         -1, fileno (pgpout), fileno (pgperr),
1382                                         pgpinfile, keylist, flags)) == -1) {
1383     mutt_perror (_("Can't invoke PGP"));
1384
1385     fclose (pgpout);
1386     fclose (pgperr);
1387     mutt_unlink (pgpinfile);
1388     unlink (pgpoutfile);
1389     return NULL;
1390   }
1391
1392   if (pgp_use_gpg_agent ())
1393     *PgpPass = 0;
1394   if (flags & SIGN)
1395     fprintf (pgpin, "%s\n", PgpPass);
1396   fclose (pgpin);
1397
1398   if (mutt_wait_filter (thepid) && option (OPTPGPCHECKEXIT))
1399     empty = 1;
1400
1401   mutt_unlink (pgpinfile);
1402
1403   fflush (pgpout);
1404   fflush (pgperr);
1405
1406   rewind (pgpout);
1407   rewind (pgperr);
1408
1409   if (!empty)
1410     empty = (fgetc (pgpout) == EOF);
1411   fclose (pgpout);
1412
1413   err = 0;
1414
1415   while (fgets (buff, sizeof (buff), pgperr)) {
1416     err = 1;
1417     fputs (buff, stdout);
1418   }
1419
1420   fclose (pgperr);
1421
1422   if (err)
1423     mutt_any_key_to_continue (NULL);
1424
1425   if (empty) {
1426     if (flags & SIGN)
1427       pgp_void_passphrase (); /* just in case */
1428     unlink (pgpoutfile);
1429     return NULL;
1430   }
1431
1432   b = mutt_new_body ();
1433
1434   b->encoding = ENC7BIT;
1435
1436   b->type = TYPETEXT;
1437   b->subtype = str_dup ("plain");
1438
1439   mutt_set_parameter ("x-action",
1440                       flags & ENCRYPT ? "pgp-encrypted" : "pgp-signed",
1441                       &b->parameter);
1442   mutt_set_parameter ("charset", send_charset, &b->parameter);
1443
1444   b->filename = str_dup (pgpoutfile);
1445
1446 #if 0
1447   /* The following is intended to give a clue to some completely brain-dead 
1448    * "mail environments" which are typically used by large corporations.
1449    */
1450
1451   b->d_filename = str_dup ("msg.pgp");
1452   b->use_disp = 1;
1453
1454 #endif
1455
1456   b->disposition = DISPINLINE;
1457   b->unlink = 1;
1458
1459   b->noconv = 1;
1460   b->use_disp = 0;
1461
1462   if (!(flags & ENCRYPT))
1463     b->encoding = a->encoding;
1464
1465   return b;
1466 }
1467
1468 int pgp_send_menu (HEADER * msg, int *redraw)
1469 {
1470   pgp_key_t p;
1471   char input_signas[SHORT_STRING];
1472
1473   char prompt[LONG_STRING];
1474
1475   if (!(WithCrypto & APPLICATION_PGP))
1476     return msg->security;
1477
1478   /* If autoinline and no crypto options set, then set inline. */
1479   if (option (OPTPGPAUTOINLINE) && !((msg->security & APPLICATION_PGP)
1480                                      && (msg->security & (SIGN | ENCRYPT))))
1481     msg->security |= INLINE;
1482
1483   snprintf (prompt, sizeof (prompt),
1484             _("PGP (e)ncrypt, (s)ign, sign (a)s, (b)oth, %s, or (c)lear? "),
1485             (msg->security & INLINE) ? _("PGP/M(i)ME") : _("(i)nline"));
1486
1487   switch (mutt_multi_choice (prompt, _("esabifc"))) {
1488   case 1:                      /* (e)ncrypt */
1489     msg->security |= ENCRYPT;
1490     msg->security &= ~SIGN;
1491     break;
1492
1493   case 2:                      /* (s)ign */
1494     msg->security |= SIGN;
1495     msg->security &= ~ENCRYPT;
1496     break;
1497
1498   case 3:                      /* sign (a)s */
1499     unset_option (OPTPGPCHECKTRUST);
1500
1501     if ((p =
1502          pgp_ask_for_key (_("Sign as: "), NULL, KEYFLAG_CANSIGN,
1503                           PGP_PUBRING))) {
1504       snprintf (input_signas, sizeof (input_signas), "0x%s", pgp_keyid (p));
1505       str_replace (&PgpSignAs, input_signas);
1506       pgp_free_key (&p);
1507
1508       msg->security |= SIGN;
1509
1510       crypt_pgp_void_passphrase ();     /* probably need a different passphrase */
1511     }
1512 #if 0
1513     else {
1514       msg->security &= ~SIGN;
1515     }
1516 #endif
1517
1518     *redraw = REDRAW_FULL;
1519     break;
1520
1521   case 4:                      /* (b)oth */
1522     msg->security |= (ENCRYPT | SIGN);
1523     break;
1524
1525   case 5:                      /* (i)nline */
1526     if ((msg->security & (ENCRYPT | SIGN)))
1527       msg->security ^= INLINE;
1528     else
1529       msg->security &= ~INLINE;
1530     break;
1531
1532   case 6:                      /* (f)orget it */
1533   case 7:                      /* (c)lear     */
1534     msg->security = 0;
1535     break;
1536   }
1537
1538   if (msg->security) {
1539     if (!(msg->security & (ENCRYPT | SIGN)))
1540       msg->security = 0;
1541     else
1542       msg->security |= APPLICATION_PGP;
1543   }
1544
1545   return (msg->security);
1546 }
1547
1548
1549 #endif /* CRYPT_BACKEND_CLASSIC_PGP */