pgp.c

   1 /*
   2  * Copyright (C) 1996,1997 Michael R. Elkins <me@mutt.org>
   3  * Copyright (C) 1998,1999 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)) != 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 body_charset[STRING];
 268   mutt_get_body_charset (body_charset, sizeof (body_charset), m);
 269
 270   rc = 0;       /* silence false compiler warning if (s->flags & M_DISPLAY) */
 271
 272   fseeko (s->fpin, m->offset, 0);
 273   last_pos = m->offset;
 274
 275   for (bytes = m->length; bytes > 0;)
 276   {
 277     if (fgets (buf, sizeof (buf), s->fpin) == NULL)
 278       break;
 279
 280     offset = ftello (s->fpin);
 281     bytes -= (offset - last_pos); /* don't rely on mutt_strlen(buf) */
 282     last_pos = offset;
 283
 284     if (mutt_strncmp ("-----BEGIN PGP ", buf, 15) == 0)
 285     {
 286       clearsign = 0;
 287       start_pos = last_pos;
 288
 289       if (mutt_strcmp ("MESSAGE-----\n", buf + 15) == 0)
 290         needpass = 1;
 291       else if (mutt_strcmp ("SIGNED MESSAGE-----\n", buf + 15) == 0)
 292       {
 293         clearsign = 1;
 294         needpass = 0;
 295       }
 296       else if (!option (OPTDONTHANDLEPGPKEYS) &&
 297                mutt_strcmp ("PUBLIC KEY BLOCK-----\n", buf + 15) == 0)
 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);
 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       }
 336
 337       /* leave tmpfp open in case we still need it - but flush it! */
 338       fflush (tmpfp);
 339
 340       /* Invoke PGP if needed */
 341       if (!clearsign || (s->flags & M_VERIFY))
 342       {
 343         mutt_mktemp (outfile);
 344         if ((pgpout = safe_fopen (outfile, "w+")) == NULL)
 345         {
 346           mutt_perror (tmpfname);
 347           return -1;
 348         }
 349
 350         if ((thepid = pgp_invoke_decode (&pgpin, NULL, &pgperr, -1,
 351                                          fileno (pgpout), -1, tmpfname,
 352                                          needpass)) == -1)
 353         {
 354           safe_fclose (&pgpout);
 355           maybe_goodsig = 0;
 356           pgpin = NULL;
 357           pgperr = NULL;
 358           state_attach_puts (_("[-- Error: unable to create PGP subprocess! --]\n"), s);
 359         }
 360         else /* PGP started successfully */
 361         {
 362           if (needpass)
 363           {
 364             if (!pgp_valid_passphrase ()) pgp_void_passphrase();
 365             if (pgp_use_gpg_agent())
 366               *PgpPass = 0;
 367             fprintf (pgpin, "%s\n", PgpPass);
 368           }
 369
 370           safe_fclose (&pgpin);
 371
 372           if (s->flags & M_DISPLAY)
 373           {
 374             crypt_current_time (s, "PGP");
 375             rc = pgp_copy_checksig (pgperr, s->fpout);
 376           }
 377
 378           safe_fclose (&pgperr);
 379           rv = mutt_wait_filter (thepid);
 380
 381           if (s->flags & M_DISPLAY)
 382           {
 383             if (rc == 0) have_any_sigs = 1;
 384             /*
 385              * Sig is bad if
 386              * gpg_good_sign-pattern did not match || pgp_decode_command returned not 0
 387              * Sig _is_ correct if
 388              *  gpg_good_sign="" && pgp_decode_command returned 0
 389              */
 390             if (rc == -1 || rv) maybe_goodsig = 0;
 391
 392             state_attach_puts (_("[-- End of PGP output --]\n\n"), s);
 393           }
 394         }
 395
 396         /* treat empty result as sign of failure */
 397         /* TODO: maybe on failure mutt should include the original undecoded text. */
 398         if (pgpout)
 399         {
 400           rewind (pgpout);
 401           c = fgetc (pgpout);
 402           ungetc (c, pgpout);
 403         }
 404         if (!clearsign && (!pgpout || c == EOF))
 405         {
 406           could_not_decrypt = 1;
 407           pgp_void_passphrase ();
 408         }
 409
 410         if (could_not_decrypt && !(s->flags & M_DISPLAY))
 411         {
 412           mutt_error _("Could not decrypt PGP message");
 413           mutt_sleep (1);
 414           rc = -1;
 415           goto out;
 416         }
 417       }
 418
 419       /*
 420        * Now, copy cleartext to the screen.  NOTE - we expect that PGP
 421        * outputs utf-8 cleartext.  This may not always be true, but it
 422        * seems to be a reasonable guess.
 423        */
 424
 425       if(s->flags & M_DISPLAY)
 426       {
 427         if (needpass)
 428           state_attach_puts (_("[-- BEGIN PGP MESSAGE --]\n\n"), s);
 429         else if (pgp_keyblock)
 430           state_attach_puts (_("[-- BEGIN PGP PUBLIC KEY BLOCK --]\n"), s);
 431         else
 432           state_attach_puts (_("[-- BEGIN PGP SIGNED MESSAGE --]\n\n"), s);
 433       }
 434
 435       if (clearsign)
 436       {
 437         rewind (tmpfp);
 438         if (tmpfp)
 439           pgp_copy_clearsigned (tmpfp, s, body_charset);
 440       }
 441       else if (pgpout)
 442       {
 443         FGETCONV *fc;
 444         int c;
 445         rewind (pgpout);
 446         state_set_prefix (s);
 447         fc = fgetconv_open (pgpout, "utf-8", Charset, 0);
 448         while ((c = fgetconv (fc)) != EOF)
 449           state_prefix_putc (c, s);
 450         fgetconv_close (&fc);
 451       }
 452
 453       if (s->flags & M_DISPLAY)
 454       {
 455         state_putc ('\n', s);
 456         if (needpass)
 457         {
 458           state_attach_puts (_("[-- END PGP MESSAGE --]\n"), s);
 459           if (could_not_decrypt)
 460             mutt_error _("Could not decrypt PGP message");
 461           else
 462             mutt_message _("PGP message successfully decrypted.");
 463         }
 464         else if (pgp_keyblock)
 465           state_attach_puts (_("[-- END PGP PUBLIC KEY BLOCK --]\n"), s);
 466         else
 467           state_attach_puts (_("[-- END PGP SIGNED MESSAGE --]\n"), s);
 468       }
 469     }
 470     else
 471     {
 472       /* XXX - we may wish to recode here */
 473       if (s->prefix)
 474         state_puts (s->prefix, s);
 475       state_puts (buf, s);
 476     }
 477   }
 478
 479   rc = 0;
 480
 481 out:
 482   m->goodsig = (maybe_goodsig && have_any_sigs);
 483
 484   if (tmpfp)
 485   {
 486     safe_fclose (&tmpfp);
 487     mutt_unlink (tmpfname);
 488   }
 489   if (pgpout)
 490   {
 491     safe_fclose (&pgpout);
 492     mutt_unlink (outfile);
 493   }
 494
 495   if (needpass == -1)
 496   {
 497     state_attach_puts (_("[-- Error: could not find beginning of PGP message! --]\n\n"), s);
 498     return -1;
 499   }
 500
 501   return rc;
 502 }
 503
 504 static int pgp_check_traditional_one_body (FILE *fp, BODY *b, int tagged_only)
 505 {
 506   char tempfile[_POSIX_PATH_MAX];
 507   char buf[HUGE_STRING];
 508   FILE *tfp;
 509
 510   short sgn = 0;
 511   short enc = 0;
 512   short key = 0;
 513
 514   if (b->type != TYPETEXT)
 515     return 0;
 516
 517   if (tagged_only && !b->tagged)
 518     return 0;
 519
 520   mutt_mktemp (tempfile);
 521   if (mutt_decode_save_attachment (fp, b, tempfile, 0, 0) != 0)
 522   {
 523     unlink (tempfile);
 524     return 0;
 525   }
 526
 527   if ((tfp = fopen (tempfile, "r")) == NULL)
 528   {
 529     unlink (tempfile);
 530     return 0;
 531   }
 532
 533   while (fgets (buf, sizeof (buf), tfp))
 534   {
 535     if (mutt_strncmp ("-----BEGIN PGP ", buf, 15) == 0)
 536     {
 537       if (mutt_strcmp ("MESSAGE-----\n", buf + 15) == 0)
 538         enc = 1;
 539       else if (mutt_strcmp ("SIGNED MESSAGE-----\n", buf + 15) == 0)
 540         sgn = 1;
 541       else if (mutt_strcmp ("PUBLIC KEY BLOCK-----\n", buf + 15) == 0)
 542         key = 1;
 543     }
 544   }
 545   safe_fclose (&tfp);
 546   unlink (tempfile);
 547
 548   if (!enc && !sgn && !key)
 549     return 0;
 550
 551   /* fix the content type */
 552
 553   mutt_set_parameter ("format", "fixed", &b->parameter);
 554   if (enc)
 555     mutt_set_parameter ("x-action", "pgp-encrypted", &b->parameter);
 556   else if (sgn)
 557     mutt_set_parameter ("x-action", "pgp-signed", &b->parameter);
 558   else if (key)
 559     mutt_set_parameter ("x-action", "pgp-keys", &b->parameter);
 560
 561   return 1;
 562 }
 563
 564 int pgp_check_traditional (FILE *fp, BODY *b, int tagged_only)
 565 {
 566   int rv = 0;
 567   int r;
 568   for (; b; b = b->next)
 569   {
 570     if (is_multipart (b))
 571       rv = pgp_check_traditional (fp, b->parts, tagged_only) || rv;
 572     else if (b->type == TYPETEXT)
 573     {
 574       if ((r = mutt_is_application_pgp (b)))
 575         rv = rv || r;
 576       else
 577         rv = pgp_check_traditional_one_body (fp, b, tagged_only) || rv;
 578     }
 579   }
 580
 581   return rv;
 582 }
 583
 584
 585
 586
 587
 588 int pgp_verify_one (BODY *sigbdy, STATE *s, const char *tempfile)
 589 {
 590   char sigfile[_POSIX_PATH_MAX], pgperrfile[_POSIX_PATH_MAX];
 591   FILE *fp, *pgpout, *pgperr;
 592   pid_t thepid;
 593   int badsig = -1;
 594   int rv;
 595
 596   snprintf (sigfile, sizeof (sigfile), "%s.asc", tempfile);
 597
 598   if(!(fp = safe_fopen (sigfile, "w")))
 599   {
 600     mutt_perror(sigfile);
 601     return -1;
 602   }
 603
 604   fseeko (s->fpin, sigbdy->offset, 0);
 605   mutt_copy_bytes (s->fpin, fp, sigbdy->length);
 606   fclose (fp);
 607
 608   mutt_mktemp(pgperrfile);
 609   if(!(pgperr = safe_fopen(pgperrfile, "w+")))
 610   {
 611     mutt_perror(pgperrfile);
 612     unlink(sigfile);
 613     return -1;
 614   }
 615
 616   crypt_current_time (s, "PGP");
 617
 618   if((thepid = pgp_invoke_verify (NULL, &pgpout, NULL,
 619                                    -1, -1, fileno(pgperr),
 620                                    tempfile, sigfile)) != -1)
 621   {
 622     if (pgp_copy_checksig (pgpout, s->fpout) >= 0)
 623       badsig = 0;
 624
 625
 626     safe_fclose (&pgpout);
 627     fflush (pgperr);
 628     rewind (pgperr);
 629
 630     if (pgp_copy_checksig  (pgperr, s->fpout) >= 0)
 631       badsig = 0;
 632
 633     if ((rv = mutt_wait_filter (thepid)))
 634       badsig = -1;
 635
 636      dprint (1, (debugfile, "pgp_verify_one: mutt_wait_filter returned %d.\n", rv));
 637   }
 638
 639   safe_fclose (&pgperr);
 640
 641   state_attach_puts (_("[-- End of PGP output --]\n\n"), s);
 642
 643   mutt_unlink (sigfile);
 644   mutt_unlink (pgperrfile);
 645
 646   dprint (1, (debugfile, "pgp_verify_one: returning %d.\n", badsig));
 647
 648   return badsig;
 649 }
 650
 651
 652 /* Extract pgp public keys from messages or attachments */
 653
 654 void pgp_extract_keys_from_messages (HEADER *h)
 655 {
 656   int i;
 657   char tempfname[_POSIX_PATH_MAX];
 658   FILE *fpout;
 659
 660   if (h)
 661   {
 662     mutt_parse_mime_message (Context, h);
 663     if(h->security & PGPENCRYPT && !pgp_valid_passphrase ())
 664       return;
 665   }
 666
 667   mutt_mktemp (tempfname);
 668   if (!(fpout = safe_fopen (tempfname, "w")))
 669   {
 670     mutt_perror (tempfname);
 671     return;
 672   }
 673
 674   set_option (OPTDONTHANDLEPGPKEYS);
 675
 676   if (!h)
 677   {
 678     for (i = 0; i < Context->vcount; i++)
 679     {
 680       if (Context->hdrs[Context->v2r[i]]->tagged)
 681       {
 682         mutt_parse_mime_message (Context, Context->hdrs[Context->v2r[i]]);
 683         if (Context->hdrs[Context->v2r[i]]->security & PGPENCRYPT
 684            && !pgp_valid_passphrase())
 685         {
 686           fclose (fpout);
 687           goto bailout;
 688         }
 689         mutt_copy_message (fpout, Context, Context->hdrs[Context->v2r[i]],
 690                            M_CM_DECODE|M_CM_CHARCONV, 0);
 691       }
 692     }
 693   }
 694   else
 695   {
 696     mutt_parse_mime_message (Context, h);
 697     if (h->security & PGPENCRYPT && !pgp_valid_passphrase())
 698     {
 699       fclose (fpout);
 700       goto bailout;
 701     }
 702     mutt_copy_message (fpout, Context, h, M_CM_DECODE|M_CM_CHARCONV, 0);
 703   }
 704
 705   fclose (fpout);
 706   mutt_endwin (NULL);
 707   pgp_invoke_import (tempfname);
 708   mutt_any_key_to_continue (NULL);
 709
 710   bailout:
 711
 712   mutt_unlink (tempfname);
 713   unset_option (OPTDONTHANDLEPGPKEYS);
 714
 715 }
 716
 717 static void pgp_extract_keys_from_attachment (FILE *fp, BODY *top)
 718 {
 719   STATE s;
 720   FILE *tempfp;
 721   char tempfname[_POSIX_PATH_MAX];
 722
 723   mutt_mktemp (tempfname);
 724   if (!(tempfp = safe_fopen (tempfname, "w")))
 725   {
 726     mutt_perror (tempfname);
 727     return;
 728   }
 729
 730   memset (&s, 0, sizeof (STATE));
 731
 732   s.fpin = fp;
 733   s.fpout = tempfp;
 734
 735   mutt_body_handler (top, &s);
 736
 737   fclose (tempfp);
 738
 739   pgp_invoke_import (tempfname);
 740   mutt_any_key_to_continue (NULL);
 741
 742   mutt_unlink (tempfname);
 743 }
 744
 745 void pgp_extract_keys_from_attachment_list (FILE *fp, int tag, BODY *top)
 746 {
 747   if(!fp)
 748   {
 749     mutt_error _("Internal error. Inform <roessler@does-not-exist.org>.");
 750     return;
 751   }
 752
 753   mutt_endwin (NULL);
 754   set_option(OPTDONTHANDLEPGPKEYS);
 755
 756   for(; top; top = top->next)
 757   {
 758     if(!tag || top->tagged)
 759       pgp_extract_keys_from_attachment (fp, top);
 760
 761     if(!tag)
 762       break;
 763   }
 764
 765   unset_option(OPTDONTHANDLEPGPKEYS);
 766 }
 767
 768 BODY *pgp_decrypt_part (BODY *a, STATE *s, FILE *fpout, BODY *p)
 769 {
 770   char buf[LONG_STRING];
 771   FILE *pgpin, *pgpout, *pgperr, *pgptmp;
 772   struct stat info;
 773   BODY *tattach;
 774   int len;
 775   char pgperrfile[_POSIX_PATH_MAX];
 776   char pgptmpfile[_POSIX_PATH_MAX];
 777   pid_t thepid;
 778   int rv;
 779
 780   mutt_mktemp (pgperrfile);
 781   if ((pgperr = safe_fopen (pgperrfile, "w+")) == NULL)
 782   {
 783     mutt_perror (pgperrfile);
 784     return NULL;
 785   }
 786   unlink (pgperrfile);
 787
 788   mutt_mktemp (pgptmpfile);
 789   if((pgptmp = safe_fopen (pgptmpfile, "w")) == NULL)
 790   {
 791     mutt_perror (pgptmpfile);
 792     fclose(pgperr);
 793     return NULL;
 794   }
 795
 796   /* Position the stream at the beginning of the body, and send the data to
 797    * the temporary file.
 798    */
 799
 800   fseeko (s->fpin, a->offset, 0);
 801   mutt_copy_bytes (s->fpin, pgptmp, a->length);
 802   fclose (pgptmp);
 803
 804   if ((thepid = pgp_invoke_decrypt (&pgpin, &pgpout, NULL, -1, -1,
 805                                     fileno (pgperr), pgptmpfile)) == -1)
 806   {
 807     fclose (pgperr);
 808     unlink (pgptmpfile);
 809     if (s->flags & M_DISPLAY)
 810       state_attach_puts (_("[-- Error: could not create a PGP subprocess! --]\n\n"), s);
 811     return (NULL);
 812   }
 813
 814   /* send the PGP passphrase to the subprocess.  Never do this if the
 815      agent is active, because this might lead to a passphrase send as
 816      the message. */
 817   if (!pgp_use_gpg_agent())
 818     fputs (PgpPass, pgpin);
 819   fputc ('\n', pgpin);
 820   fclose(pgpin);
 821
 822   /* Read the output from PGP, and make sure to change CRLF to LF, otherwise
 823    * read_mime_header has a hard time parsing the message.
 824    */
 825   while (fgets (buf, sizeof (buf) - 1, pgpout) != NULL)
 826   {
 827     len = mutt_strlen (buf);
 828     if (len > 1 && buf[len - 2] == '\r')
 829       strcpy (buf + len - 2, "\n");     /* __STRCPY_CHECKED__ */
 830     fputs (buf, fpout);
 831   }
 832
 833   fclose (pgpout);
 834   rv = mutt_wait_filter (thepid);
 835   mutt_unlink(pgptmpfile);
 836
 837   if (s->flags & M_DISPLAY)
 838   {
 839     fflush (pgperr);
 840     rewind (pgperr);
 841     if (pgp_copy_checksig (pgperr, s->fpout) == 0 && !rv && p)
 842       p->goodsig = 1;
 843     else
 844       p->goodsig = 0;
 845     state_attach_puts (_("[-- End of PGP output --]\n\n"), s);
 846   }
 847   fclose (pgperr);
 848
 849   fflush (fpout);
 850   rewind (fpout);
 851
 852   if (fgetc (fpout) == EOF)
 853   {
 854     mutt_error _("Decryption failed");
 855     pgp_void_passphrase ();
 856     return NULL;
 857   }
 858
 859   rewind (fpout);
 860
 861   if ((tattach = mutt_read_mime_header (fpout, 0)) != NULL)
 862   {
 863     /*
 864      * Need to set the length of this body part.
 865      */
 866     fstat (fileno (fpout), &info);
 867     tattach->length = info.st_size - tattach->offset;
 868
 869     /* See if we need to recurse on this MIME part.  */
 870
 871     mutt_parse_part (fpout, tattach);
 872   }
 873
 874   return (tattach);
 875 }
 876
 877 int pgp_decrypt_mime (FILE *fpin, FILE **fpout, BODY *b, BODY **cur)
 878 {
 879   char tempfile[_POSIX_PATH_MAX];
 880   STATE s;
 881   BODY *p = b;
 882
 883   if(!mutt_is_multipart_encrypted(b))
 884     return -1;
 885
 886   if(!b->parts || !b->parts->next)
 887     return -1;
 888
 889   b = b->parts->next;
 890
 891   memset (&s, 0, sizeof (s));
 892   s.fpin = fpin;
 893   mutt_mktemp (tempfile);
 894   if ((*fpout = safe_fopen (tempfile, "w+")) == NULL)
 895   {
 896     mutt_perror (tempfile);
 897     return (-1);
 898   }
 899   unlink (tempfile);
 900
 901   *cur = pgp_decrypt_part (b, &s, *fpout, p);
 902
 903   rewind (*fpout);
 904
 905   if (!*cur)
 906     return -1;
 907
 908   return (0);
 909 }
 910
 911 int pgp_encrypted_handler (BODY *a, STATE *s)
 912 {
 913   char tempfile[_POSIX_PATH_MAX];
 914   FILE *fpout, *fpin;
 915   BODY *tattach;
 916   BODY *p = a;
 917   int rc = 0;
 918
 919   a = a->parts;
 920   if (!a || a->type != TYPEAPPLICATION || !a->subtype ||
 921       ascii_strcasecmp ("pgp-encrypted", a->subtype) != 0 ||
 922       !a->next || a->next->type != TYPEAPPLICATION || !a->next->subtype ||
 923       ascii_strcasecmp ("octet-stream", a->next->subtype) != 0)
 924   {
 925     if (s->flags & M_DISPLAY)
 926       state_attach_puts (_("[-- Error: malformed PGP/MIME message! --]\n\n"), s);
 927     return -1;
 928   }
 929
 930   /*
 931    * Move forward to the application/pgp-encrypted body.
 932    */
 933   a = a->next;
 934
 935   mutt_mktemp (tempfile);
 936   if ((fpout = safe_fopen (tempfile, "w+")) == NULL)
 937   {
 938     if (s->flags & M_DISPLAY)
 939       state_attach_puts (_("[-- Error: could not create temporary file! --]\n"), s);
 940     return -1;
 941   }
 942
 943   if (s->flags & M_DISPLAY) crypt_current_time (s, "PGP");
 944
 945   if ((tattach = pgp_decrypt_part (a, s, fpout, p)) != NULL)
 946   {
 947     if (s->flags & M_DISPLAY)
 948       state_attach_puts (_("[-- The following data is PGP/MIME encrypted --]\n\n"), s);
 949
 950     fpin = s->fpin;
 951     s->fpin = fpout;
 952     rc = mutt_body_handler (tattach, s);
 953     s->fpin = fpin;
 954
 955     /*
 956      * if a multipart/signed is the _only_ sub-part of a
 957      * multipart/encrypted, cache signature verification
 958      * status.
 959      *
 960      */
 961
 962     if (mutt_is_multipart_signed (tattach) && !tattach->next)
 963       p->goodsig |= tattach->goodsig;
 964
 965     if (s->flags & M_DISPLAY)
 966     {
 967       state_puts ("\n", s);
 968       state_attach_puts (_("[-- End of PGP/MIME encrypted data --]\n"), s);
 969     }
 970
 971     mutt_free_body (&tattach);
 972     /* clear 'Invoking...' message, since there's no error */
 973     mutt_message _("PGP message successfully decrypted.");
 974   }
 975   else
 976   {
 977     mutt_error _("Could not decrypt PGP message");
 978     /* void the passphrase, even if it's not necessarily the problem */
 979     pgp_void_passphrase ();
 980     rc = -1;
 981   }
 982
 983   fclose (fpout);
 984   mutt_unlink(tempfile);
 985
 986   return rc;
 987 }
 988
 989 /* ----------------------------------------------------------------------------
 990  * Routines for sending PGP/MIME messages.
 991  */
 992
 993
 994 BODY *pgp_sign_message (BODY *a)
 995 {
 996   BODY *t;
 997   char buffer[LONG_STRING];
 998   char sigfile[_POSIX_PATH_MAX], signedfile[_POSIX_PATH_MAX];
 999   FILE *pgpin, *pgpout, *pgperr, *fp, *sfp;
1000   int err = 0;
1001   int empty = 1;
1002   pid_t thepid;
1003
1004   convert_to_7bit (a); /* Signed data _must_ be in 7-bit format. */
1005
1006   mutt_mktemp (sigfile);
1007   if ((fp = safe_fopen (sigfile, "w")) == NULL)
1008   {
1009     return (NULL);
1010   }
1011
1012   mutt_mktemp (signedfile);
1013   if ((sfp = safe_fopen(signedfile, "w")) == NULL)
1014   {
1015     mutt_perror(signedfile);
1016     fclose(fp);
1017     unlink(sigfile);
1018     return NULL;
1019   }
1020
1021   mutt_write_mime_header (a, sfp);
1022   fputc ('\n', sfp);
1023   mutt_write_mime_body (a, sfp);
1024   fclose(sfp);
1025
1026   if ((thepid = pgp_invoke_sign (&pgpin, &pgpout, &pgperr,
1027                                  -1, -1, -1, signedfile)) == -1)
1028   {
1029     mutt_perror _("Can't open PGP subprocess!");
1030     fclose(fp);
1031     unlink(sigfile);
1032     unlink(signedfile);
1033     return NULL;
1034   }
1035
1036   if (!pgp_use_gpg_agent())
1037      fputs(PgpPass, pgpin);
1038   fputc('\n', pgpin);
1039   fclose(pgpin);
1040
1041   /*
1042    * Read back the PGP signature.  Also, change MESSAGE=>SIGNATURE as
1043    * recommended for future releases of PGP.
1044    */
1045   while (fgets (buffer, sizeof (buffer) - 1, pgpout) != NULL)
1046   {
1047     if (mutt_strcmp ("-----BEGIN PGP MESSAGE-----\n", buffer) == 0)
1048       fputs ("-----BEGIN PGP SIGNATURE-----\n", fp);
1049     else if (mutt_strcmp("-----END PGP MESSAGE-----\n", buffer) == 0)
1050       fputs ("-----END PGP SIGNATURE-----\n", fp);
1051     else
1052       fputs (buffer, fp);
1053     empty = 0; /* got some output, so we're ok */
1054   }
1055
1056   /* check for errors from PGP */
1057   err = 0;
1058   while (fgets (buffer, sizeof (buffer) - 1, pgperr) != NULL)
1059   {
1060     err = 1;
1061     fputs (buffer, stdout);
1062   }
1063
1064   if(mutt_wait_filter (thepid) && option(OPTPGPCHECKEXIT))
1065     empty=1;
1066
1067   fclose (pgperr);
1068   fclose (pgpout);
1069   unlink (signedfile);
1070
1071   if (fclose (fp) != 0)
1072   {
1073     mutt_perror ("fclose");
1074     unlink (sigfile);
1075     return (NULL);
1076   }
1077
1078   if (err)
1079     mutt_any_key_to_continue (NULL);
1080   if (empty)
1081   {
1082     unlink (sigfile);
1083     /* most likely error is a bad passphrase, so automatically forget it */
1084     pgp_void_passphrase ();
1085     return (NULL); /* fatal error while signing */
1086   }
1087
1088   t = mutt_new_body ();
1089   t->type = TYPEMULTIPART;
1090   t->subtype = safe_strdup ("signed");
1091   t->encoding = ENC7BIT;
1092   t->use_disp = 0;
1093   t->disposition = DISPINLINE;
1094
1095   mutt_generate_boundary (&t->parameter);
1096   mutt_set_parameter ("protocol", "application/pgp-signature", &t->parameter);
1097   mutt_set_parameter ("micalg", pgp_micalg (sigfile), &t->parameter);
1098
1099   t->parts = a;
1100   a = t;
1101
1102   t->parts->next = mutt_new_body ();
1103   t = t->parts->next;
1104   t->type = TYPEAPPLICATION;
1105   t->subtype = safe_strdup ("pgp-signature");
1106   t->filename = safe_strdup (sigfile);
1107   t->use_disp = 0;
1108   t->disposition = DISPINLINE;
1109   t->encoding = ENC7BIT;
1110   t->unlink = 1; /* ok to remove this file after sending. */
1111
1112   return (a);
1113 }
1114
1115 static short is_numerical_keyid (const char *s)
1116 {
1117   /* or should we require the "0x"? */
1118   if (strncmp (s, "0x", 2) == 0)
1119     s += 2;
1120   if (strlen (s) % 8)
1121     return 0;
1122   while (*s)
1123     if (strchr ("0123456789ABCDEFabcdef", *s++) == NULL)
1124       return 0;
1125
1126   return 1;
1127 }
1128
1129 /* This routine attempts to find the keyids of the recipients of a message.
1130  * It returns NULL if any of the keys can not be found.
1131  */
1132 char *pgp_findKeys (ADDRESS *to, ADDRESS *cc, ADDRESS *bcc)
1133 {
1134   char *keyID, *keylist = NULL, *t;
1135   size_t keylist_size = 0;
1136   size_t keylist_used = 0;
1137   ADDRESS *tmp = NULL, *addr = NULL;
1138   ADDRESS **last = &tmp;
1139   ADDRESS *p, *q;
1140   int i;
1141   pgp_key_t k_info = NULL, key = NULL;
1142
1143   const char *fqdn = mutt_fqdn (1);
1144
1145   for (i = 0; i < 3; i++)
1146   {
1147     switch (i)
1148     {
1149       case 0: p = to; break;
1150       case 1: p = cc; break;
1151       case 2: p = bcc; break;
1152       default: abort ();
1153     }
1154
1155     *last = rfc822_cpy_adr (p);
1156     while (*last)
1157       last = &((*last)->next);
1158   }
1159
1160   if (fqdn)
1161     rfc822_qualify (tmp, fqdn);
1162
1163   tmp = mutt_remove_duplicates (tmp);
1164
1165   for (p = tmp; p ; p = p->next)
1166   {
1167     char buf[LONG_STRING];
1168
1169     q = p;
1170     k_info = NULL;
1171
1172     if ((keyID = mutt_crypt_hook (p)) != NULL)
1173     {
1174       int r;
1175       snprintf (buf, sizeof (buf), _("Use keyID = \"%s\" for %s?"), keyID, p->mailbox);
1176       if ((r = mutt_yesorno (buf, M_YES)) == M_YES)
1177       {
1178         if (is_numerical_keyid (keyID))
1179         {
1180           if (strncmp (keyID, "0x", 2) == 0)
1181             keyID += 2;
1182           goto bypass_selection;                /* you don't see this. */
1183         }
1184
1185         /* check for e-mail address */
1186         if ((t = strchr (keyID, '@')) &&
1187             (addr = rfc822_parse_adrlist (NULL, keyID)))
1188         {
1189           if (fqdn) rfc822_qualify (addr, fqdn);
1190           q = addr;
1191         }
1192         else
1193           k_info = pgp_getkeybystr (keyID, KEYFLAG_CANENCRYPT, PGP_PUBRING);
1194       }
1195       else if (r == -1)
1196       {
1197         FREE (&keylist);
1198         rfc822_free_address (&tmp);
1199         rfc822_free_address (&addr);
1200         return NULL;
1201       }
1202     }
1203
1204     if (k_info == NULL)
1205       pgp_invoke_getkeys (q);
1206
1207     if (k_info == NULL && (k_info = pgp_getkeybyaddr (q, KEYFLAG_CANENCRYPT, PGP_PUBRING)) == NULL)
1208     {
1209       snprintf (buf, sizeof (buf), _("Enter keyID for %s: "), q->mailbox);
1210
1211       if ((key = pgp_ask_for_key (buf, q->mailbox,
1212                                   KEYFLAG_CANENCRYPT, PGP_PUBRING)) == NULL)
1213       {
1214         FREE (&keylist);
1215         rfc822_free_address (&tmp);
1216         rfc822_free_address (&addr);
1217         return NULL;
1218       }
1219     }
1220     else
1221       key = k_info;
1222
1223     keyID = pgp_keyid (key);
1224
1225   bypass_selection:
1226     keylist_size += mutt_strlen (keyID) + 4;
1227     safe_realloc (&keylist, keylist_size);
1228     sprintf (keylist + keylist_used, "%s0x%s", keylist_used ? " " : "", /* __SPRINTF_CHECKED__ */
1229              keyID);
1230     keylist_used = mutt_strlen (keylist);
1231
1232     pgp_free_key (&key);
1233     rfc822_free_address (&addr);
1234
1235   }
1236   rfc822_free_address (&tmp);
1237   return (keylist);
1238 }
1239
1240 /* Warning: "a" is no longer freed in this routine, you need
1241  * to free it later.  This is necessary for $fcc_attach. */
1242
1243 BODY *pgp_encrypt_message (BODY *a, char *keylist, int sign)
1244 {
1245   char buf[LONG_STRING];
1246   char tempfile[_POSIX_PATH_MAX], pgperrfile[_POSIX_PATH_MAX];
1247   char pgpinfile[_POSIX_PATH_MAX];
1248   FILE *pgpin, *pgperr, *fpout, *fptmp;
1249   BODY *t;
1250   int err = 0;
1251   int empty = 0;
1252   pid_t thepid;
1253
1254   mutt_mktemp (tempfile);
1255   if ((fpout = safe_fopen (tempfile, "w+")) == NULL)
1256   {
1257     mutt_perror (tempfile);
1258     return (NULL);
1259   }
1260
1261   mutt_mktemp (pgperrfile);
1262   if ((pgperr = safe_fopen (pgperrfile, "w+")) == NULL)
1263   {
1264     mutt_perror (pgperrfile);
1265     unlink(tempfile);
1266     fclose(fpout);
1267     return NULL;
1268   }
1269   unlink (pgperrfile);
1270
1271   mutt_mktemp(pgpinfile);
1272   if((fptmp = safe_fopen(pgpinfile, "w")) == NULL)
1273   {
1274     mutt_perror(pgpinfile);
1275     unlink(tempfile);
1276     fclose(fpout);
1277     fclose(pgperr);
1278     return NULL;
1279   }
1280
1281   if (sign)
1282     convert_to_7bit (a);
1283
1284   mutt_write_mime_header (a, fptmp);
1285   fputc ('\n', fptmp);
1286   mutt_write_mime_body (a, fptmp);
1287   fclose(fptmp);
1288
1289   if ((thepid = pgp_invoke_encrypt (&pgpin, NULL, NULL, -1,
1290                                     fileno (fpout), fileno (pgperr),
1291                                     pgpinfile, keylist, sign)) == -1)
1292   {
1293     fclose (pgperr);
1294     unlink(pgpinfile);
1295     return (NULL);
1296   }
1297
1298   if (sign)
1299   {
1300     if (!pgp_use_gpg_agent())
1301        fputs (PgpPass, pgpin);
1302     fputc ('\n', pgpin);
1303   }
1304   fclose(pgpin);
1305
1306   if(mutt_wait_filter (thepid) && option(OPTPGPCHECKEXIT))
1307     empty=1;
1308
1309   unlink(pgpinfile);
1310
1311   fflush (fpout);
1312   rewind (fpout);
1313   if(!empty)
1314     empty = (fgetc (fpout) == EOF);
1315   fclose (fpout);
1316
1317   fflush (pgperr);
1318   rewind (pgperr);
1319   while (fgets (buf, sizeof (buf) - 1, pgperr) != NULL)
1320   {
1321     err = 1;
1322     fputs (buf, stdout);
1323   }
1324   fclose (pgperr);
1325
1326   /* pause if there is any error output from PGP */
1327   if (err)
1328     mutt_any_key_to_continue (NULL);
1329
1330   if (empty)
1331   {
1332     /* fatal error while trying to encrypt message */
1333     if (sign)
1334       pgp_void_passphrase (); /* just in case */
1335     unlink (tempfile);
1336     return (NULL);
1337   }
1338
1339   t = mutt_new_body ();
1340   t->type = TYPEMULTIPART;
1341   t->subtype = safe_strdup ("encrypted");
1342   t->encoding = ENC7BIT;
1343   t->use_disp = 0;
1344   t->disposition = DISPINLINE;
1345
1346   mutt_generate_boundary(&t->parameter);
1347   mutt_set_parameter("protocol", "application/pgp-encrypted", &t->parameter);
1348
1349   t->parts = mutt_new_body ();
1350   t->parts->type = TYPEAPPLICATION;
1351   t->parts->subtype = safe_strdup ("pgp-encrypted");
1352   t->parts->encoding = ENC7BIT;
1353
1354   t->parts->next = mutt_new_body ();
1355   t->parts->next->type = TYPEAPPLICATION;
1356   t->parts->next->subtype = safe_strdup ("octet-stream");
1357   t->parts->next->encoding = ENC7BIT;
1358   t->parts->next->filename = safe_strdup (tempfile);
1359   t->parts->next->use_disp = 1;
1360   t->parts->next->disposition = DISPINLINE;
1361   t->parts->next->unlink = 1; /* delete after sending the message */
1362   t->parts->next->d_filename = safe_strdup ("msg.asc"); /* non pgp/mime can save */
1363
1364   return (t);
1365 }
1366
1367 BODY *pgp_traditional_encryptsign (BODY *a, int flags, char *keylist)
1368 {
1369   BODY *b;
1370
1371   char pgpoutfile[_POSIX_PATH_MAX];
1372   char pgperrfile[_POSIX_PATH_MAX];
1373   char pgpinfile[_POSIX_PATH_MAX];
1374
1375   char body_charset[STRING];
1376   char *from_charset;
1377   const char *send_charset;
1378
1379   FILE *pgpout = NULL, *pgperr = NULL, *pgpin = NULL;
1380   FILE *fp;
1381
1382   int empty = 0;
1383   int err;
1384
1385   char buff[STRING];
1386
1387   pid_t thepid;
1388
1389   if (a->type != TYPETEXT)
1390     return NULL;
1391   if (ascii_strcasecmp (a->subtype, "plain"))
1392     return NULL;
1393
1394   if ((fp = fopen (a->filename, "r")) == NULL)
1395   {
1396     mutt_perror (a->filename);
1397     return NULL;
1398   }
1399
1400   mutt_mktemp (pgpinfile);
1401   if ((pgpin = safe_fopen (pgpinfile, "w")) == NULL)
1402   {
1403     mutt_perror (pgpinfile);
1404     fclose (fp);
1405     return NULL;
1406   }
1407
1408   /* The following code is really correct:  If noconv is set,
1409    * a's charset parameter contains the on-disk character set, and
1410    * we have to convert from that to utf-8.  If noconv is not set,
1411    * we have to convert from $charset to utf-8.
1412    */
1413
1414   mutt_get_body_charset (body_charset, sizeof (body_charset), a);
1415   if (a->noconv)
1416     from_charset = body_charset;
1417   else
1418     from_charset = Charset;
1419
1420   if (!mutt_is_us_ascii (body_charset))
1421   {
1422     int c;
1423     FGETCONV *fc;
1424
1425     if (flags & ENCRYPT)
1426       send_charset = "us-ascii";
1427     else
1428       send_charset = "utf-8";
1429
1430     /* fromcode is assumed to be correct: we set flags to 0 */
1431     fc = fgetconv_open (fp, from_charset, "utf-8", 0);
1432     while ((c = fgetconv (fc)) != EOF)
1433       fputc (c, pgpin);
1434
1435     fgetconv_close (&fc);
1436   }
1437   else
1438   {
1439     send_charset = "us-ascii";
1440     mutt_copy_stream (fp, pgpin);
1441   }
1442   safe_fclose (&fp);
1443   fclose (pgpin);
1444
1445   mutt_mktemp (pgpoutfile);
1446   mutt_mktemp (pgperrfile);
1447   if ((pgpout = safe_fopen (pgpoutfile, "w+")) == NULL ||
1448       (pgperr = safe_fopen (pgperrfile, "w+")) == NULL)
1449   {
1450     mutt_perror (pgpout ? pgperrfile : pgpoutfile);
1451     unlink (pgpinfile);
1452     if (pgpout)
1453     {
1454       fclose (pgpout);
1455       unlink (pgpoutfile);
1456     }
1457     return NULL;
1458   }
1459
1460   unlink (pgperrfile);
1461
1462   if ((thepid = pgp_invoke_traditional (&pgpin, NULL, NULL,
1463                                         -1, fileno (pgpout), fileno (pgperr),
1464                                         pgpinfile, keylist, flags)) == -1)
1465   {
1466     mutt_perror _("Can't invoke PGP");
1467     fclose (pgpout);
1468     fclose (pgperr);
1469     mutt_unlink (pgpinfile);
1470     unlink (pgpoutfile);
1471     return NULL;
1472   }
1473
1474   if (pgp_use_gpg_agent())
1475     *PgpPass = 0;
1476   if (flags & SIGN)
1477     fprintf (pgpin, "%s\n", PgpPass);
1478   fclose (pgpin);
1479
1480   if(mutt_wait_filter (thepid) && option(OPTPGPCHECKEXIT))
1481     empty=1;
1482
1483   mutt_unlink (pgpinfile);
1484
1485   fflush (pgpout);
1486   fflush (pgperr);
1487
1488   rewind (pgpout);
1489   rewind (pgperr);
1490
1491   if(!empty)
1492     empty = (fgetc (pgpout) == EOF);
1493   fclose (pgpout);
1494
1495   err = 0;
1496
1497   while (fgets (buff, sizeof (buff), pgperr))
1498   {
1499     err = 1;
1500     fputs (buff, stdout);
1501   }
1502
1503   fclose (pgperr);
1504
1505   if (err)
1506     mutt_any_key_to_continue (NULL);
1507
1508   if (empty)
1509   {
1510     if (flags & SIGN)
1511       pgp_void_passphrase (); /* just in case */
1512     unlink (pgpoutfile);
1513     return NULL;
1514   }
1515
1516   b = mutt_new_body ();
1517
1518   b->encoding = ENC7BIT;
1519
1520   b->type = TYPETEXT;
1521   b->subtype = safe_strdup ("plain");
1522
1523   mutt_set_parameter ("x-action", flags & ENCRYPT ? "pgp-encrypted" : "pgp-signed",
1524                       &b->parameter);
1525   mutt_set_parameter ("charset", send_charset, &b->parameter);
1526
1527   b->filename = safe_strdup (pgpoutfile);
1528
1529 #if 0
1530   /* The following is intended to give a clue to some completely brain-dead
1531    * "mail environments" which are typically used by large corporations.
1532    */
1533
1534   b->d_filename = safe_strdup ("msg.pgp");
1535   b->use_disp = 1;
1536
1537 #endif
1538
1539   b->disposition = DISPINLINE;
1540   b->unlink   = 1;
1541
1542   b->noconv = 1;
1543   b->use_disp = 0;
1544
1545   if (!(flags & ENCRYPT))
1546     b->encoding = a->encoding;
1547
1548   return b;
1549 }
1550
1551 int pgp_send_menu (HEADER *msg, int *redraw)
1552 {
1553   pgp_key_t p;
1554   char input_signas[SHORT_STRING];
1555
1556   char prompt[LONG_STRING];
1557
1558   if (!(WithCrypto & APPLICATION_PGP))
1559     return msg->security;
1560
1561   /* If autoinline and no crypto options set, then set inline. */
1562   if (option (OPTPGPAUTOINLINE) &&
1563       !((msg->security & APPLICATION_PGP) && (msg->security & (SIGN|ENCRYPT))))
1564     msg->security |= INLINE;
1565
1566   snprintf (prompt, sizeof (prompt),
1567             _("PGP (e)ncrypt, (s)ign, sign (a)s, (b)oth, %s, or (c)lear? "),
1568             (msg->security & INLINE) ? _("PGP/M(i)ME") : _("(i)nline"));
1569
1570   switch (mutt_multi_choice (prompt, _("esabifc")))
1571   {
1572   case 1: /* (e)ncrypt */
1573     msg->security |= ENCRYPT;
1574     msg->security &= ~SIGN;
1575     break;
1576
1577   case 2: /* (s)ign */
1578     msg->security |= SIGN;
1579     msg->security &= ~ENCRYPT;
1580     break;
1581
1582   case 3: /* sign (a)s */
1583     unset_option(OPTPGPCHECKTRUST);
1584
1585     if ((p = pgp_ask_for_key (_("Sign as: "), NULL, 0, PGP_SECRING)))
1586     {
1587       snprintf (input_signas, sizeof (input_signas), "0x%s",
1588                 pgp_keyid (p));
1589       mutt_str_replace (&PgpSignAs, input_signas);
1590       pgp_free_key (&p);
1591
1592       msg->security |= SIGN;
1593
1594       crypt_pgp_void_passphrase ();  /* probably need a different passphrase */
1595     }
1596 #if 0
1597     else
1598     {
1599       msg->security &= ~SIGN;
1600     }
1601 #endif
1602
1603     *redraw = REDRAW_FULL;
1604     break;
1605
1606   case 4: /* (b)oth */
1607     msg->security |= (ENCRYPT | SIGN);
1608     break;
1609
1610   case 5: /* (i)nline */
1611     if ((msg->security & (ENCRYPT | SIGN)))
1612       msg->security ^= INLINE;
1613     else
1614       msg->security &= ~INLINE;
1615     break;
1616
1617   case 6: /* (f)orget it */
1618   case 7: /* (c)lear     */
1619     msg->security = 0;
1620     break;
1621   }
1622
1623   if (msg->security)
1624   {
1625     if (! (msg->security & (ENCRYPT | SIGN)))
1626       msg->security = 0;
1627     else
1628       msg->security |= APPLICATION_PGP;
1629   }
1630
1631   return (msg->security);
1632 }
1633
1634
1635 #endif /* CRYPT_BACKEND_CLASSIC_PGP */