pgp.c

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