smime.c

   1 /*
   2  * Copyright (C) 2001,2002 Oliver Ehli <elmy@acm.org>
   3  * Copyright (C) 2002 Mike Schiraldi <raldi@research.netsol.com>
   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 #if HAVE_CONFIG_H
  22 # include "config.h"
  23 #endif
  24
  25 #include "mutt.h"
  26 #include "mutt_curses.h"
  27 #include "mutt_menu.h"
  28 #include "smime.h"
  29 #include "mime.h"
  30 #include "copy.h"
  31
  32 #include <sys/wait.h>
  33 #include <string.h>
  34 #include <stdlib.h>
  35 #include <unistd.h>
  36 #include <sys/stat.h>
  37 #include <errno.h>
  38 #include <ctype.h>
  39
  40 #ifdef HAVE_LOCALE_H
  41 #include <locale.h>
  42 #endif
  43
  44 #ifdef HAVE_SYS_TIME_H
  45 # include <sys/time.h>
  46 #endif
  47
  48 #ifdef HAVE_SYS_RESOURCE_H
  49 # include <sys/resource.h>
  50 #endif
  51
  52 #ifdef CRYPT_BACKEND_CLASSIC_SMIME
  53
  54 #include "mutt_crypt.h"
  55
  56 struct smime_command_context {
  57   const char *key;                  /* %k */
  58   const char *cryptalg;             /* %a */
  59   const char *fname;                /* %f */
  60   const char *sig_fname;            /* %s */
  61   const char *certificates;         /* %c */
  62   const char *intermediates;        /* %i */
  63 };
  64
  65
  66 typedef struct {
  67   unsigned int hash;
  68   char suffix;
  69   char email[256];
  70   char nick[256];
  71   char trust; /* i=Invalid r=revoked e=expired u=unverified v=verified t=trusted */
  72   short public; /* 1=public 0=private */
  73 } smime_id;
  74
  75
  76 char SmimePass[STRING];
  77 time_t SmimeExptime = 0; /* when does the cached passphrase expire? */
  78
  79
  80 static char SmimeKeyToUse[_POSIX_PATH_MAX] = { 0 };
  81 static char SmimeCertToUse[_POSIX_PATH_MAX];
  82 static char SmimeIntermediateToUse[_POSIX_PATH_MAX];
  83
  84
  85 /*
  86  *     Queries and passphrase handling.
  87  */
  88
  89
  90
  91
  92 /* these are copies from pgp.c */
  93
  94
  95 void smime_void_passphrase (void)
  96 {
  97   memset (SmimePass, 0, sizeof (SmimePass));
  98   SmimeExptime = 0;
  99 }
 100
 101 int smime_valid_passphrase (void)
 102 {
 103   time_t now = time (NULL);
 104
 105   if (now < SmimeExptime)
 106     /* Use cached copy.  */
 107     return 1;
 108
 109   smime_void_passphrase();
 110
 111   if (mutt_get_password (_("Enter S/MIME passphrase:"), SmimePass, sizeof (SmimePass)) == 0)
 112     {
 113       SmimeExptime = time (NULL) + SmimeTimeout;
 114       return (1);
 115     }
 116   else
 117     SmimeExptime = 0;
 118
 119   return 0;
 120 }
 121
 122
 123 /*
 124  *     The OpenSSL interface
 125  */
 126
 127 /* This is almost identical to ppgp's invoking interface. */
 128
 129 static const char *_mutt_fmt_smime_command (char *dest,
 130                                             size_t destlen,
 131                                             size_t col,
 132                                             char op,
 133                                             const char *src,
 134                                             const char *prefix,
 135                                             const char *ifstring,
 136                                             const char *elsestring,
 137                                             unsigned long data,
 138                                             format_flag flags)
 139 {
 140   char fmt[16];
 141   struct smime_command_context *cctx = (struct smime_command_context *) data;
 142   int optional = (flags & M_FORMAT_OPTIONAL);
 143
 144   switch (op)
 145   {
 146     case 'C':
 147     {
 148       if (!optional)
 149       {
 150         char path[_POSIX_PATH_MAX];
 151         char buf1[LONG_STRING], buf2[LONG_STRING];
 152         struct stat sb;
 153
 154         strfcpy (path, NONULL (SmimeCALocation), sizeof (path));
 155         mutt_expand_path (path, sizeof (path));
 156         mutt_quote_filename (buf1, sizeof (buf1), path);
 157
 158         if (stat (path, &sb) != 0 || !S_ISDIR (sb.st_mode))
 159           snprintf (buf2, sizeof (buf2), "-CAfile %s", buf1);
 160         else
 161           snprintf (buf2, sizeof (buf2), "-CApath %s", buf1);
 162
 163         snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
 164         snprintf (dest, destlen, fmt, buf2);
 165       }
 166       else if (!SmimeCALocation)
 167         optional = 0;
 168       break;
 169     }
 170
 171     case 'c':
 172     {           /* certificate (list) */
 173       if (!optional) {
 174         snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
 175         snprintf (dest, destlen, fmt, NONULL(cctx->certificates));
 176       }
 177       else if (!cctx->certificates)
 178         optional = 0;
 179       break;
 180     }
 181
 182     case 'i':
 183     {           /* intermediate certificates  */
 184       if (!optional) {
 185         snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
 186         snprintf (dest, destlen, fmt, NONULL(cctx->intermediates));
 187       }
 188       else if (!cctx->intermediates)
 189         optional = 0;
 190       break;
 191     }
 192
 193     case 's':
 194     {           /* detached signature */
 195       if (!optional)
 196       {
 197         snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
 198         snprintf (dest, destlen, fmt, NONULL (cctx->sig_fname));
 199       }
 200       else if (!cctx->sig_fname)
 201         optional = 0;
 202       break;
 203     }
 204
 205     case 'k':
 206     {           /* private key */
 207       if (!optional)
 208       {
 209         snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
 210         snprintf (dest, destlen, fmt, NONULL (cctx->key));
 211       }
 212       else if (!cctx->key)
 213         optional = 0;
 214       break;
 215     }
 216
 217     case 'a':
 218     {           /* algorithm for encryption */
 219       if (!optional) {
 220         snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
 221         snprintf (dest, destlen, fmt, NONULL (cctx->cryptalg));
 222       }
 223       else if (!cctx->key)
 224         optional = 0;
 225       break;
 226     }
 227
 228     case 'f':
 229     {           /* file to process */
 230       if (!optional)
 231       {
 232         snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
 233         snprintf (dest, destlen, fmt, NONULL (cctx->fname));
 234       }
 235       else if (!cctx->fname)
 236         optional = 0;
 237       break;
 238     }
 239
 240     default:
 241       *dest = '\0';
 242       break;
 243   }
 244
 245   if (optional)
 246     mutt_FormatString (dest, destlen, col, ifstring, _mutt_fmt_smime_command,
 247                        data, 0);
 248   else if (flags & M_FORMAT_OPTIONAL)
 249     mutt_FormatString (dest, destlen, col, elsestring, _mutt_fmt_smime_command,
 250                        data, 0);
 251
 252   return (src);
 253 }
 254
 255
 256
 257 static void mutt_smime_command (char *d, size_t dlen,
 258                                 struct smime_command_context *cctx, const char *fmt)
 259 {
 260   mutt_FormatString (d, dlen, 0, NONULL(fmt), _mutt_fmt_smime_command,
 261                     (unsigned long) cctx, 0);
 262   dprint (2,(debugfile, "mutt_smime_command: %s\n", d));
 263 }
 264
 265
 266
 267
 268 static pid_t smime_invoke (FILE **smimein, FILE **smimeout, FILE **smimeerr,
 269                            int smimeinfd, int smimeoutfd, int smimeerrfd,
 270                            const char *fname,
 271                            const char *sig_fname,
 272                            const char *cryptalg,
 273                            const char *key,
 274                            const char *certificates,
 275                            const char *intermediates,
 276                            const char *format)
 277 {
 278   struct smime_command_context cctx;
 279   char cmd[HUGE_STRING];
 280
 281   memset (&cctx, 0, sizeof (cctx));
 282
 283   if (!format || !*format)
 284     return (pid_t) -1;
 285
 286   cctx.fname           = fname;
 287   cctx.sig_fname       = sig_fname;
 288   cctx.key             = key;
 289   cctx.cryptalg        = cryptalg;
 290   cctx.certificates    = certificates;
 291   cctx.intermediates   = intermediates;
 292
 293   mutt_smime_command (cmd, sizeof (cmd), &cctx, format);
 294
 295   return mutt_create_filter_fd (cmd, smimein, smimeout, smimeerr,
 296                                 smimeinfd, smimeoutfd, smimeerrfd);
 297 }
 298
 299
 300
 301
 302
 303
 304 /*
 305  *    Key and certificate handling.
 306  */
 307
 308
 309
 310 /*
 311    Search the certificate index for given mailbox.
 312    return certificate file name.
 313 */
 314
 315 static void smime_entry (char *s, size_t l, MUTTMENU * menu, int num)
 316 {
 317   smime_id *Table = (smime_id*) menu->data;
 318   smime_id this = Table[num];
 319   char* truststate;
 320   switch(this.trust) {
 321     case 't':
 322       truststate = N_("Trusted   ");
 323       break;
 324     case 'v':
 325       truststate = N_("Verified  ");
 326       break;
 327     case 'u':
 328       truststate = N_("Unverified");
 329       break;
 330     case 'e':
 331       truststate = N_("Expired   ");
 332       break;
 333     case 'r':
 334       truststate = N_("Revoked   ");
 335       break;
 336     case 'i':
 337       truststate = N_("Invalid   ");
 338       break;
 339     default:
 340       truststate = N_("Unknown   ");
 341   }
 342   if (this.public)
 343     snprintf(s, l, " 0x%.8X.%i %s %-35.35s %s", this.hash, this.suffix, truststate, this.email, this.nick);
 344   else
 345     snprintf(s, l, " 0x%.8X.%i %-35.35s %s", this.hash, this.suffix, this.email, this.nick);
 346 }
 347
 348
 349
 350
 351
 352 char* smime_ask_for_key (char *prompt, char *mailbox, short public)
 353 {
 354   char *fname;
 355   smime_id *Table;
 356   long cert_num; /* Will contain the number of certificates.
 357       * To be able to get it, the .index file will be read twice... */
 358   char index_file[_POSIX_PATH_MAX];
 359   FILE *index;
 360   char buf[LONG_STRING];
 361   char fields[5][STRING];
 362   int numFields, hash_suffix, done, cur; /* The current entry */
 363   MUTTMENU* menu;
 364   unsigned int hash;
 365   char helpstr[HUGE_STRING*3];
 366   char qry[256];
 367   char title[256];
 368
 369   if (!prompt) prompt = _("Enter keyID: ");
 370   snprintf(index_file, sizeof (index_file), "%s/.index",
 371     public ? NONULL(SmimeCertificates) : NONULL(SmimeKeys));
 372
 373   index = fopen(index_file, "r");
 374   if (index == NULL)
 375   {
 376     mutt_perror (index_file);
 377     return NULL;
 378   }
 379   /* Count Lines */
 380   cert_num = 0;
 381   while (!feof(index)) {
 382     if (fgets(buf, sizeof(buf), index)) cert_num++;
 383   }
 384   fclose(index);
 385
 386   FOREVER
 387   {
 388     *qry = 0;
 389     if (mutt_get_field(prompt,
 390       qry, sizeof(qry), 0))
 391       return NULL;
 392     snprintf(title, sizeof(title), _("S/MIME certificates matching \"%s\"."),
 393       qry);
 394
 395
 396     index = fopen(index_file, "r");
 397     if (index == NULL)
 398     {
 399       mutt_perror (index_file);
 400       return NULL;
 401     }
 402     /* Read Entries */
 403     cur = 0;
 404     Table = safe_calloc(cert_num, sizeof (smime_id));
 405     while (!feof(index)) {
 406         numFields = fscanf (index, MUTT_FORMAT(STRING) " %x.%i " MUTT_FORMAT(STRING), fields[0], &hash,
 407           &hash_suffix, fields[2]);
 408         if (public)
 409           fscanf (index, MUTT_FORMAT(STRING) " " MUTT_FORMAT(STRING) "\n", fields[3], fields[4]);
 410
 411       /* 0=email 1=name 2=nick 3=intermediate 4=trust */
 412       if (numFields < 2) continue;
 413
 414       /* Check if query matches this certificate */
 415       if (!mutt_stristr(fields[0], qry) &&
 416           !mutt_stristr(fields[2], qry))
 417         continue;
 418
 419       Table[cur].hash = hash;
 420       Table[cur].suffix = hash_suffix;
 421       strncpy(Table[cur].email, fields[0], sizeof(Table[cur].email));
 422       strncpy(Table[cur].nick, fields[2], sizeof(Table[cur].nick));
 423       Table[cur].trust = *fields[4];
 424       Table[cur].public = public;
 425
 426       cur++;
 427     }
 428     fclose(index);
 429
 430     /* Make Helpstring */
 431     helpstr[0] = 0;
 432     mutt_make_help (buf, sizeof (buf), _("Exit  "), MENU_SMIME, OP_EXIT);
 433     strcat (helpstr, buf);      /* __STRCAT_CHECKED__ */
 434     mutt_make_help (buf, sizeof (buf), _("Select  "), MENU_SMIME,
 435         OP_GENERIC_SELECT_ENTRY);
 436     strcat (helpstr, buf);      /* __STRCAT_CHECKED__ */
 437     mutt_make_help (buf, sizeof(buf), _("Help"), MENU_SMIME, OP_HELP);
 438     strcat (helpstr, buf);      /* __STRCAT_CHECKED__ */
 439
 440     /* Create the menu */
 441     menu = mutt_new_menu(MENU_SMIME);
 442     menu->max = cur;
 443     menu->make_entry = smime_entry;
 444     menu->help = helpstr;
 445     menu->data = Table;
 446     menu->title = title;
 447     /* sorting keys might be done later - TODO */
 448
 449     mutt_clear_error();
 450
 451     done = 0;
 452     hash = 0;
 453     while (!done) {
 454       switch (mutt_menuLoop (menu)) {
 455         case OP_GENERIC_SELECT_ENTRY:
 456           cur = menu->current;
 457         hash = 1;
 458           done = 1;
 459           break;
 460         case OP_EXIT:
 461           hash = 0;
 462           done = 1;
 463           break;
 464       }
 465     }
 466     if (hash) {
 467       fname = safe_malloc(13); /* Hash + '.' + Suffix + \0 */
 468       sprintf(fname, "%.8x.%i", Table[cur].hash, Table[cur].suffix);
 469     }
 470     else fname = NULL;
 471
 472     mutt_menuDestroy (&menu);
 473     FREE (&Table);
 474     set_option (OPTNEEDREDRAW);
 475
 476     if (fname) return fname;
 477   }
 478 }
 479
 480
 481
 482 char *smime_get_field_from_db (char *mailbox, char *query, short public, short may_ask)
 483 {
 484   int addr_len, query_len, found = 0, ask = 0, choice = 0;
 485   char cert_path[_POSIX_PATH_MAX];
 486   char buf[LONG_STRING], prompt[STRING];
 487   char fields[5][STRING];
 488   char key[STRING];
 489   int numFields;
 490   struct stat info;
 491   char key_trust_level = 0;
 492   FILE *fp;
 493
 494   if(!mailbox && !query) return(NULL);
 495
 496   addr_len = mailbox ? mutt_strlen (mailbox) : 0;
 497   query_len = query ? mutt_strlen (query) : 0;
 498
 499   *key = '\0';
 500
 501   /* index-file format:
 502      mailbox certfile label issuer_certfile trust_flags\n
 503
 504      certfile is a hash value generated by openssl.
 505      Note that this was done according to the OpenSSL
 506      specs on their CA-directory.
 507
 508   */
 509   snprintf (cert_path, sizeof (cert_path), "%s/.index",
 510             (public ? NONULL(SmimeCertificates) : NONULL(SmimeKeys)));
 511
 512   if (!stat (cert_path, &info))
 513   {
 514     if ((fp = safe_fopen (cert_path, "r")) == NULL)
 515     {
 516       mutt_perror (cert_path);
 517       return (NULL);
 518     }
 519
 520     while (fgets (buf, sizeof (buf) - 1, fp) != NULL)
 521       if (mailbox && !(mutt_strncasecmp (mailbox, buf, addr_len)))
 522       {
 523         numFields = sscanf (buf,
 524                             MUTT_FORMAT(STRING) " " MUTT_FORMAT(STRING) " "
 525                             MUTT_FORMAT(STRING) " " MUTT_FORMAT(STRING) " "
 526                             MUTT_FORMAT(STRING) "\n",
 527                             fields[0], fields[1],
 528                            fields[2], fields[3],
 529                             fields[4]);
 530         if (numFields < 2)
 531             continue;
 532         if (mailbox && public &&
 533             (*fields[4] == 'i' || *fields[4] == 'e' || *fields[4] == 'r'))
 534             continue;
 535
 536         if (found)
 537         {
 538           if (public && *fields[4] == 'u' )
 539             snprintf (prompt, sizeof (prompt),
 540                       _("ID %s is unverified. Do you want to use it for %s ?"),
 541                       fields[1], mailbox);
 542           else if (public && *fields[4] == 'v' )
 543             snprintf (prompt, sizeof (prompt),
 544                       _("Use (untrusted!) ID %s for %s ?"),
 545                       fields[1], mailbox);
 546           else
 547             snprintf (prompt, sizeof (prompt), _("Use ID %s for %s ?"),
 548                       fields[1], mailbox);
 549           if (may_ask == 0)
 550             choice = M_YES;
 551           if (may_ask && (choice = mutt_yesorno (prompt, M_NO)) == -1)
 552           {
 553             found = 0;
 554             ask = 0;
 555             *key = '\0';
 556             break;
 557           }
 558           else if (choice == M_NO)
 559           {
 560             ask = 1;
 561             continue;
 562           }
 563           else if (choice == M_YES)
 564           {
 565             strfcpy (key, fields[1], sizeof (key));
 566             ask = 0;
 567             break;
 568           }
 569         }
 570         else
 571         {
 572           if (public)
 573             key_trust_level = *fields[4];
 574           strfcpy (key, fields[1], sizeof (key));
 575         }
 576         found = 1;
 577       }
 578       else if(query)
 579       {
 580         numFields = sscanf (buf,
 581                             MUTT_FORMAT(STRING) " " MUTT_FORMAT(STRING) " "
 582                             MUTT_FORMAT(STRING) " " MUTT_FORMAT(STRING) " "
 583                             MUTT_FORMAT(STRING) "\n",
 584                             fields[0], fields[1],
 585                             fields[2], fields[3],
 586                             fields[4]);
 587
 588         /* query = label: return certificate. */
 589         if (numFields >= 3 &&
 590             !(mutt_strncasecmp (query, fields[2], query_len)))
 591         {
 592           ask = 0;
 593           strfcpy (key, fields[1], sizeof (key));
 594         }
 595         /* query = certificate: return intermediate certificate. */
 596         else if (numFields >= 4 &&
 597                  !(mutt_strncasecmp (query, fields[1], query_len)))
 598         {
 599           ask = 0;
 600           strfcpy (key, fields[3], sizeof (key));
 601         }
 602       }
 603
 604     safe_fclose (&fp);
 605
 606     if (ask)
 607     {
 608       if (public && *fields[4] == 'u' )
 609         snprintf (prompt, sizeof (prompt),
 610                   _("ID %s is unverified. Do you want to use it for %s ?"),
 611                   fields[1], mailbox);
 612       else if (public && *fields[4] == 'v' )
 613         snprintf (prompt, sizeof (prompt),
 614                   _("Use (untrusted!) ID %s for %s ?"),
 615                   fields[1], mailbox);
 616       else
 617         snprintf (prompt, sizeof(prompt), _("Use ID %s for %s ?"), key,
 618                   mailbox);
 619       choice = mutt_yesorno (prompt, M_NO);
 620       if (choice == -1 || choice == M_NO)
 621         *key = '\0';
 622     }
 623     else if (key_trust_level && may_ask)
 624     {
 625       if (key_trust_level == 'u' )
 626       {
 627         snprintf (prompt, sizeof (prompt),
 628                   _("ID %s is unverified. Do you want to use it for %s ?"),
 629                   key, mailbox);
 630         choice = mutt_yesorno (prompt, M_NO);
 631         if (choice != M_YES)
 632           *key = '\0';
 633       }
 634       else if (key_trust_level == 'v' )
 635       {
 636         mutt_error (_("Warning: You have not yet decided to trust ID %s. (any key to continue)"), key);
 637         mutt_sleep (5);
 638       }
 639     }
 640
 641   }
 642
 643   /* Note: safe_strdup ("") returns NULL. */
 644   return safe_strdup (key);
 645 }
 646
 647
 648
 649
 650 /*
 651    This sets the '*ToUse' variables for an upcoming decryption, where
 652    the reuquired key is different from SmimeDefaultKey.
 653 */
 654
 655 void _smime_getkeys (char *mailbox)
 656 {
 657   char *k = NULL;
 658   char buf[STRING];
 659
 660   k = smime_get_field_from_db (mailbox, NULL, 0, 1);
 661
 662   if (!k)
 663   {
 664     snprintf(buf, sizeof(buf), _("Enter keyID for %s: "),
 665              mailbox);
 666     k = smime_ask_for_key(buf, mailbox, 0);
 667   }
 668
 669   if (k)
 670   {
 671     /* the key used last time. */
 672     if (*SmimeKeyToUse &&
 673         !mutt_strcasecmp (k, SmimeKeyToUse + mutt_strlen (SmimeKeys)+1))
 674     {
 675       FREE (&k);
 676       return;
 677     }
 678     else smime_void_passphrase ();
 679
 680     snprintf (SmimeKeyToUse, sizeof (SmimeKeyToUse), "%s/%s",
 681               NONULL(SmimeKeys), k);
 682
 683     snprintf (SmimeCertToUse, sizeof (SmimeCertToUse), "%s/%s",
 684               NONULL(SmimeCertificates), k);
 685
 686     if (mutt_strcasecmp (k, SmimeDefaultKey))
 687       smime_void_passphrase ();
 688
 689     FREE (&k);
 690     return;
 691   }
 692
 693   if (*SmimeKeyToUse)
 694   {
 695     if (!mutt_strcasecmp (SmimeDefaultKey,
 696                           SmimeKeyToUse + mutt_strlen (SmimeKeys)+1))
 697       return;
 698
 699     smime_void_passphrase ();
 700   }
 701
 702   snprintf (SmimeKeyToUse, sizeof (SmimeKeyToUse), "%s/%s",
 703             NONULL (SmimeKeys), NONULL (SmimeDefaultKey));
 704
 705   snprintf (SmimeCertToUse, sizeof (SmimeCertToUse), "%s/%s",
 706             NONULL (SmimeCertificates), NONULL (SmimeDefaultKey));
 707 }
 708
 709 void smime_getkeys (ENVELOPE *env)
 710 {
 711   ADDRESS *t;
 712   int found = 0;
 713
 714   if (option (OPTSDEFAULTDECRYPTKEY) && SmimeDefaultKey && *SmimeDefaultKey)
 715   {
 716     snprintf (SmimeKeyToUse, sizeof (SmimeKeyToUse), "%s/%s",
 717               NONULL (SmimeKeys), SmimeDefaultKey);
 718
 719     snprintf (SmimeCertToUse, sizeof (SmimeCertToUse), "%s/%s",
 720               NONULL(SmimeCertificates), SmimeDefaultKey);
 721
 722     return;
 723   }
 724
 725   for (t = env->to; !found && t; t = t->next)
 726     if (mutt_addr_is_user (t))
 727     {
 728       found = 1;
 729       _smime_getkeys (t->mailbox);
 730     }
 731   for (t = env->cc; !found && t; t = t->next)
 732     if (mutt_addr_is_user (t))
 733     {
 734       found = 1;
 735       _smime_getkeys (t->mailbox);
 736     }
 737   if (!found && (t = mutt_default_from()))
 738   {
 739     _smime_getkeys (t->mailbox);
 740     rfc822_free_address (&t);
 741   }
 742 }
 743
 744 /* This routine attempts to find the keyids of the recipients of a message.
 745  * It returns NULL if any of the keys can not be found.
 746  */
 747
 748 char *smime_findKeys (ADDRESS *to, ADDRESS *cc, ADDRESS *bcc)
 749 {
 750   char *keyID, *keylist = NULL;
 751   size_t keylist_size = 0;
 752   size_t keylist_used = 0;
 753   ADDRESS *tmp = NULL, *addr = NULL;
 754   ADDRESS **last = &tmp;
 755   ADDRESS *p, *q;
 756   int i;
 757
 758   const char *fqdn = mutt_fqdn (1);
 759
 760   for (i = 0; i < 3; i++)
 761   {
 762     switch (i)
 763     {
 764       case 0: p = to; break;
 765       case 1: p = cc; break;
 766       case 2: p = bcc; break;
 767       default: abort ();
 768     }
 769
 770     *last = rfc822_cpy_adr (p);
 771     while (*last)
 772       last = &((*last)->next);
 773   }
 774
 775   if (fqdn)
 776     rfc822_qualify (tmp, fqdn);
 777
 778   tmp = mutt_remove_duplicates (tmp);
 779
 780   for (p = tmp; p ; p = p->next)
 781   {
 782     char buf[LONG_STRING];
 783
 784     q = p;
 785
 786     if ((keyID = smime_get_field_from_db (q->mailbox, NULL, 1, 1)) == NULL)
 787     {
 788       snprintf(buf, sizeof(buf),
 789                _("Enter keyID for %s: "),
 790                q->mailbox);
 791       keyID = smime_ask_for_key(buf, q->mailbox, 1);
 792     }
 793     if(!keyID)
 794     {
 795       mutt_message (_("No (valid) certificate found for %s."), q->mailbox);
 796       FREE (&keylist);
 797       rfc822_free_address (&tmp);
 798       rfc822_free_address (&addr);
 799       return NULL;
 800     }
 801
 802     keylist_size += mutt_strlen (keyID) + 2;
 803     safe_realloc (&keylist, keylist_size);
 804     sprintf (keylist + keylist_used, "%s\n", keyID);    /* __SPRINTF_CHECKED__ */
 805     keylist_used = mutt_strlen (keylist);
 806
 807     rfc822_free_address (&addr);
 808
 809   }
 810   rfc822_free_address (&tmp);
 811   return (keylist);
 812 }
 813
 814
 815
 816
 817
 818
 819 static int smime_handle_cert_email (char *certificate, char *mailbox,
 820                                    int copy, char ***buffer, int *num)
 821 {
 822   FILE *fpout = NULL, *fperr = NULL;
 823   char tmpfname[_POSIX_PATH_MAX];
 824   char email[STRING];
 825   int ret = -1, count = 0;
 826   pid_t thepid;
 827
 828   mutt_mktemp (tmpfname);
 829   if ((fperr = safe_fopen (tmpfname, "w+")) == NULL)
 830   {
 831     mutt_perror (tmpfname);
 832     return 1;
 833   }
 834   mutt_unlink (tmpfname);
 835
 836   mutt_mktemp (tmpfname);
 837   if ((fpout = safe_fopen (tmpfname, "w+")) == NULL)
 838   {
 839     fclose (fperr);
 840     mutt_perror (tmpfname);
 841     return 1;
 842   }
 843   mutt_unlink (tmpfname);
 844
 845   if ((thepid =  smime_invoke (NULL, NULL, NULL,
 846                                -1, fileno (fpout), fileno (fperr),
 847                                certificate, NULL, NULL, NULL, NULL, NULL,
 848                                SmimeGetCertEmailCommand))== -1)
 849   {
 850     mutt_message (_("Error: unable to create OpenSSL subprocess!"));
 851     fclose (fperr);
 852     fclose (fpout);
 853     return 1;
 854   }
 855
 856   mutt_wait_filter (thepid);
 857
 858   fflush (fpout);
 859   rewind (fpout);
 860   fflush (fperr);
 861   rewind (fperr);
 862
 863
 864   while ((fgets (email, sizeof (email), fpout)))
 865   {
 866     *(email + mutt_strlen (email)-1) = '\0';
 867     if(mutt_strncasecmp (email, mailbox, mutt_strlen (mailbox)) == 0)
 868       ret=1;
 869
 870     ret = ret < 0 ? 0 : ret;
 871     count++;
 872   }
 873
 874   if (ret == -1)
 875   {
 876     mutt_endwin(NULL);
 877     mutt_copy_stream (fperr, stdout);
 878     mutt_any_key_to_continue (_("Error: unable to create OpenSSL subprocess!"));
 879     ret = 1;
 880   }
 881   else if (!ret)
 882     ret = 1;
 883   else ret = 0;
 884
 885   if(copy && buffer && num)
 886   {
 887     (*num) = count;
 888     *buffer =  safe_calloc(sizeof(char*), count);
 889     count = 0;
 890
 891     rewind (fpout);
 892     while ((fgets (email, sizeof (email), fpout)))
 893     {
 894       *(email + mutt_strlen (email) - 1) = '\0';
 895       (*buffer)[count] = safe_calloc(1, mutt_strlen (email) + 1);
 896       strncpy((*buffer)[count], email, mutt_strlen (email));
 897       count++;
 898     }
 899   }
 900   else if(copy) ret = 2;
 901
 902   fclose (fpout);
 903   fclose (fperr);
 904
 905   return ret;
 906 }
 907
 908
 909
 910 static char *smime_extract_certificate (char *infile)
 911 {
 912   FILE *fpout = NULL, *fperr = NULL;
 913   char pk7out[_POSIX_PATH_MAX], certfile[_POSIX_PATH_MAX];
 914   char tmpfname[_POSIX_PATH_MAX];
 915   pid_t thepid;
 916   int empty;
 917
 918
 919   mutt_mktemp (tmpfname);
 920   if ((fperr = safe_fopen (tmpfname, "w+")) == NULL)
 921   {
 922     mutt_perror (tmpfname);
 923     return NULL;
 924   }
 925   mutt_unlink (tmpfname);
 926
 927   mutt_mktemp (pk7out);
 928   if ((fpout = safe_fopen (pk7out, "w+")) == NULL)
 929   {
 930     fclose (fperr);
 931     mutt_perror (pk7out);
 932     return NULL;
 933   }
 934
 935   /* Step 1: Convert the signature to a PKCS#7 structure, as we can't
 936      extract the full set of certificates directly.
 937   */
 938   if ((thepid =  smime_invoke (NULL, NULL, NULL,
 939                                -1, fileno (fpout), fileno (fperr),
 940                                infile, NULL, NULL, NULL, NULL, NULL,
 941                                SmimePk7outCommand))== -1)
 942   {
 943     mutt_any_key_to_continue (_("Error: unable to create OpenSSL subprocess!"));
 944     fclose (fperr);
 945     fclose (fpout);
 946     mutt_unlink (pk7out);
 947     return NULL;
 948   }
 949
 950   mutt_wait_filter (thepid);
 951
 952
 953   fflush (fpout);
 954   rewind (fpout);
 955   fflush (fperr);
 956   rewind (fperr);
 957   empty = (fgetc (fpout) == EOF);
 958   if (empty)
 959   {
 960     mutt_perror (pk7out);
 961     mutt_copy_stream (fperr, stdout);
 962     fclose (fpout);
 963     fclose (fperr);
 964     mutt_unlink (pk7out);
 965     return NULL;
 966
 967   }
 968
 969
 970   fclose (fpout);
 971   mutt_mktemp (certfile);
 972   if ((fpout = safe_fopen (certfile, "w+")) == NULL)
 973   {
 974     fclose (fperr);
 975     mutt_unlink (pk7out);
 976     mutt_perror (certfile);
 977     return NULL;
 978   }
 979
 980   /* Step 2: Extract the certificates from a PKCS#7 structure.
 981    */
 982   if ((thepid =  smime_invoke (NULL, NULL, NULL,
 983                                -1, fileno (fpout), fileno (fperr),
 984                                pk7out, NULL, NULL, NULL, NULL, NULL,
 985                                SmimeGetCertCommand))== -1)
 986   {
 987     mutt_any_key_to_continue (_("Error: unable to create OpenSSL subprocess!"));
 988     fclose (fperr);
 989     fclose (fpout);
 990     mutt_unlink (pk7out);
 991     mutt_unlink (certfile);
 992     return NULL;
 993   }
 994
 995   mutt_wait_filter (thepid);
 996
 997   mutt_unlink (pk7out);
 998
 999   fflush (fpout);
1000   rewind (fpout);
1001   fflush (fperr);
1002   rewind (fperr);
1003   empty =  (fgetc (fpout) == EOF);
1004   if (empty)
1005   {
1006     mutt_copy_stream (fperr, stdout);
1007     fclose (fpout);
1008     fclose (fperr);
1009     mutt_unlink (certfile);
1010     return NULL;
1011   }
1012
1013   fclose (fpout);
1014   fclose (fperr);
1015
1016   return safe_strdup (certfile);
1017 }
1018
1019 static char *smime_extract_signer_certificate (char *infile)
1020 {
1021   FILE *fpout = NULL, *fperr = NULL;
1022   char pk7out[_POSIX_PATH_MAX], certfile[_POSIX_PATH_MAX];
1023   char tmpfname[_POSIX_PATH_MAX];
1024   pid_t thepid;
1025   int empty;
1026
1027
1028   mutt_mktemp (tmpfname);
1029   if ((fperr = safe_fopen (tmpfname, "w+")) == NULL)
1030   {
1031     mutt_perror (tmpfname);
1032     return NULL;
1033   }
1034   mutt_unlink (tmpfname);
1035
1036
1037   mutt_mktemp (certfile);
1038   if ((fpout = safe_fopen (certfile, "w+")) == NULL)
1039   {
1040     fclose (fperr);
1041     mutt_perror (certfile);
1042     return NULL;
1043   }
1044
1045   /* Extract signer's certificate
1046    */
1047   if ((thepid =  smime_invoke (NULL, NULL, NULL,
1048                                -1, -1, fileno (fperr),
1049                                infile, NULL, NULL, NULL, certfile, NULL,
1050                                SmimeGetSignerCertCommand))== -1)
1051   {
1052     mutt_any_key_to_continue (_("Error: unable to create OpenSSL subprocess!"));
1053     fclose (fperr);
1054     fclose (fpout);
1055     mutt_unlink (pk7out);
1056     mutt_unlink (certfile);
1057     return NULL;
1058   }
1059
1060   mutt_wait_filter (thepid);
1061
1062   fflush (fpout);
1063   rewind (fpout);
1064   fflush (fperr);
1065   rewind (fperr);
1066   empty =  (fgetc (fpout) == EOF);
1067   if (empty)
1068   {
1069     mutt_endwin (NULL);
1070     mutt_copy_stream (fperr, stdout);
1071     mutt_any_key_to_continue (NULL);
1072     fclose (fpout);
1073     fclose (fperr);
1074     mutt_unlink (certfile);
1075     return NULL;
1076   }
1077
1078   fclose (fpout);
1079   fclose (fperr);
1080
1081   return safe_strdup (certfile);
1082 }
1083
1084
1085
1086
1087 /* Add a certificate and update index file (externally). */
1088
1089 void smime_invoke_import (char *infile, char *mailbox)
1090 {
1091   char tmpfname[_POSIX_PATH_MAX], *certfile = NULL, buf[STRING];
1092   FILE *smimein=NULL, *fpout = NULL, *fperr = NULL;
1093   pid_t thepid=-1;
1094
1095   mutt_mktemp (tmpfname);
1096   if ((fperr = safe_fopen (tmpfname, "w+")) == NULL)
1097   {
1098     mutt_perror (tmpfname);
1099     return;
1100   }
1101   mutt_unlink (tmpfname);
1102
1103   mutt_mktemp (tmpfname);
1104   if ((fpout = safe_fopen (tmpfname, "w+")) == NULL)
1105   {
1106     fclose (fperr);
1107     mutt_perror (tmpfname);
1108     return;
1109   }
1110   mutt_unlink (tmpfname);
1111
1112
1113   buf[0] = '\0';
1114   if (option (OPTASKCERTLABEL))
1115     mutt_get_field ("Label for certificate:", buf, sizeof (buf), 0);
1116
1117   mutt_endwin (NULL);
1118   if ((certfile = smime_extract_certificate(infile)))
1119   {
1120     mutt_endwin (NULL);
1121
1122     if ((thepid =  smime_invoke (&smimein, NULL, NULL,
1123                                  -1, fileno(fpout), fileno(fperr),
1124                                  certfile, NULL, NULL, NULL, NULL, NULL,
1125                                  SmimeImportCertCommand))== -1)
1126     {
1127       mutt_message (_("Error: unable to create OpenSSL subprocess!"));
1128       return;
1129     }
1130     fputs (buf, smimein);
1131     fputc ('\n', smimein);
1132     fclose(smimein);
1133
1134     mutt_wait_filter (thepid);
1135
1136     mutt_unlink (certfile);
1137     FREE (&certfile);
1138   }
1139
1140   fflush (fpout);
1141   rewind (fpout);
1142   fflush (fperr);
1143   rewind (fperr);
1144
1145   mutt_copy_stream (fpout, stdout);
1146   mutt_copy_stream (fperr, stdout);
1147
1148   fclose (fpout);
1149   fclose (fperr);
1150
1151 }
1152
1153
1154
1155 int smime_verify_sender(HEADER *h)
1156 {
1157   char *mbox = NULL, *certfile, tempfname[_POSIX_PATH_MAX];
1158   FILE *fpout;
1159   int retval=1;
1160
1161   mutt_mktemp (tempfname);
1162   if (!(fpout = safe_fopen (tempfname, "w")))
1163   {
1164     mutt_perror (tempfname);
1165     return 1;
1166   }
1167
1168   if(h->security & ENCRYPT)
1169     mutt_copy_message (fpout, Context, h,
1170                        M_CM_DECODE_CRYPT & M_CM_DECODE_SMIME,
1171                        CH_MIME|CH_WEED|CH_NONEWLINE);
1172   else
1173     mutt_copy_message (fpout, Context, h, 0, 0);
1174
1175   fflush(fpout);
1176   fclose (fpout);
1177
1178   if (h->env->from)
1179   {
1180     h->env->from = mutt_expand_aliases (h->env->from);
1181     mbox = h->env->from->mailbox;
1182   }
1183   else if (h->env->sender)
1184   {
1185     h->env->sender = mutt_expand_aliases (h->env->sender);
1186     mbox = h->env->sender->mailbox;
1187   }
1188
1189   if (mbox)
1190   {
1191     if ((certfile = smime_extract_signer_certificate(tempfname)))
1192     {
1193       mutt_unlink(tempfname);
1194       if (smime_handle_cert_email (certfile, mbox, 0, NULL, NULL))
1195       {
1196         if(isendwin())
1197          mutt_any_key_to_continue(NULL);
1198       }
1199       else
1200         retval = 0;
1201       mutt_unlink(certfile);
1202       FREE (&certfile);
1203     }
1204   else
1205         mutt_any_key_to_continue(_("no certfile"));
1206   }
1207   else
1208         mutt_any_key_to_continue(_("no mbox"));
1209
1210   mutt_unlink(tempfname);
1211   return retval;
1212 }
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222 /*
1223  *    Creating S/MIME - bodies.
1224  */
1225
1226
1227
1228
1229 static
1230 pid_t smime_invoke_encrypt (FILE **smimein, FILE **smimeout, FILE **smimeerr,
1231                             int smimeinfd, int smimeoutfd, int smimeerrfd,
1232                             const char *fname, const char *uids)
1233 {
1234   return smime_invoke (smimein, smimeout, smimeerr,
1235                        smimeinfd, smimeoutfd, smimeerrfd,
1236                        fname, NULL, SmimeCryptAlg, NULL, uids, NULL,
1237                        SmimeEncryptCommand);
1238 }
1239
1240
1241 static
1242 pid_t smime_invoke_sign (FILE **smimein, FILE **smimeout, FILE **smimeerr,
1243                          int smimeinfd, int smimeoutfd, int smimeerrfd,
1244                          const char *fname)
1245 {
1246   return smime_invoke (smimein, smimeout, smimeerr, smimeinfd, smimeoutfd,
1247                        smimeerrfd, fname, NULL, NULL, SmimeKeyToUse,
1248                        SmimeCertToUse, SmimeIntermediateToUse,
1249                        SmimeSignCommand);
1250 }
1251
1252
1253
1254
1255 BODY *smime_build_smime_entity (BODY *a, char *certlist)
1256 {
1257   char buf[LONG_STRING], certfile[LONG_STRING];
1258   char tempfile[_POSIX_PATH_MAX], smimeerrfile[_POSIX_PATH_MAX];
1259   char smimeinfile[_POSIX_PATH_MAX];
1260   char *cert_start = certlist, *cert_end = certlist;
1261   FILE *smimein = NULL, *smimeerr = NULL, *fpout = NULL, *fptmp = NULL;
1262   BODY *t;
1263   int err = 0, empty;
1264   pid_t thepid;
1265
1266   mutt_mktemp (tempfile);
1267   if ((fpout = safe_fopen (tempfile, "w+")) == NULL)
1268   {
1269     mutt_perror (tempfile);
1270     return (NULL);
1271   }
1272
1273   mutt_mktemp (smimeerrfile);
1274   if ((smimeerr = safe_fopen (smimeerrfile, "w+")) == NULL)
1275   {
1276     mutt_perror (smimeerrfile);
1277     fclose (fpout);
1278     mutt_unlink (tempfile);
1279     return NULL;
1280   }
1281   mutt_unlink (smimeerrfile);
1282
1283   mutt_mktemp (smimeinfile);
1284   if ((fptmp = safe_fopen (smimeinfile, "w+")) == NULL)
1285   {
1286     mutt_perror (smimeinfile);
1287     mutt_unlink (tempfile);
1288     fclose (fpout);
1289     fclose (smimeerr);
1290     return NULL;
1291   }
1292
1293   *certfile = '\0';
1294   while (1)
1295   {
1296     int off = mutt_strlen (certfile);
1297     while (*++cert_end && *cert_end != '\n');
1298     if (!*cert_end) break;
1299     *cert_end = '\0';
1300     snprintf (certfile+off, sizeof (certfile)-off, " %s/%s",
1301               NONULL(SmimeCertificates), cert_start);
1302     *cert_end = '\n';
1303     cert_start = cert_end;
1304     cert_start++;
1305   }
1306
1307   /* write a MIME entity */
1308   mutt_write_mime_header (a, fptmp);
1309   fputc ('\n', fptmp);
1310   mutt_write_mime_body (a, fptmp);
1311   fclose (fptmp);
1312
1313   if ((thepid =
1314        smime_invoke_encrypt (&smimein, NULL, NULL, -1,
1315                              fileno (fpout), fileno (smimeerr),
1316                              smimeinfile, certfile)) == -1)
1317   {
1318     fclose (smimeerr);
1319     mutt_unlink (smimeinfile);
1320     mutt_unlink (certfile);
1321     return (NULL);
1322   }
1323
1324   fclose (smimein);
1325
1326   mutt_wait_filter (thepid);
1327   mutt_unlink (smimeinfile);
1328   mutt_unlink (certfile);
1329
1330   fflush (fpout);
1331   rewind (fpout);
1332   empty = (fgetc (fpout) == EOF);
1333   fclose (fpout);
1334
1335   fflush (smimeerr);
1336   rewind (smimeerr);
1337   while (fgets (buf, sizeof (buf) - 1, smimeerr) != NULL)
1338   {
1339     err = 1;
1340     fputs (buf, stdout);
1341   }
1342   fclose (smimeerr);
1343
1344   /* pause if there is any error output from SMIME */
1345   if (err)
1346     mutt_any_key_to_continue (NULL);
1347
1348   if (empty)
1349   {
1350     /* fatal error while trying to encrypt message */
1351     if (!err) mutt_any_key_to_continue _("No output from OpenSSL..");
1352     mutt_unlink (tempfile);
1353     return (NULL);
1354   }
1355
1356   t = mutt_new_body ();
1357   t->type = TYPEAPPLICATION;
1358   t->subtype = safe_strdup ("x-pkcs7-mime");
1359   mutt_set_parameter ("name", "smime.p7m", &t->parameter);
1360   mutt_set_parameter ("smime-type", "enveloped-data", &t->parameter);
1361   t->encoding = ENCBASE64;  /* The output of OpenSSL SHOULD be binary */
1362   t->use_disp = 1;
1363   t->disposition = DISPATTACH;
1364   t->d_filename = safe_strdup ("smime.p7m");
1365   t->filename = safe_strdup (tempfile);
1366   t->unlink = 1; /*delete after sending the message */
1367   t->parts=0;
1368   t->next=0;
1369
1370   return (t);
1371 }
1372
1373
1374
1375
1376 BODY *smime_sign_message (BODY *a )
1377 {
1378   BODY *t;
1379   char buffer[LONG_STRING];
1380   char signedfile[_POSIX_PATH_MAX], filetosign[_POSIX_PATH_MAX];
1381   FILE *smimein = NULL, *smimeout = NULL, *smimeerr = NULL, *sfp = NULL;
1382   int err = 0;
1383   int empty = 0;
1384   pid_t thepid;
1385   char *intermediates = smime_get_field_from_db(NULL, SmimeDefaultKey, 1, 1);
1386
1387   if (!SmimeDefaultKey)
1388   {
1389     mutt_error _("Can't sign: No key specified. Use Sign As.");
1390     return NULL;
1391   }
1392
1393   if (!intermediates)
1394   {
1395     mutt_message(_("Warning: Intermediate certificate not found."));
1396     intermediates = SmimeDefaultKey; /* so openssl won't complain in any case */
1397   }
1398
1399   convert_to_7bit (a); /* Signed data _must_ be in 7-bit format. */
1400
1401   mutt_mktemp (filetosign);
1402   if ((sfp = safe_fopen (filetosign, "w+")) == NULL)
1403   {
1404     mutt_perror (filetosign);
1405     return NULL;
1406   }
1407
1408   mutt_mktemp (signedfile);
1409   if ((smimeout = safe_fopen (signedfile, "w+")) == NULL)
1410   {
1411     mutt_perror (signedfile);
1412     fclose (sfp);
1413     mutt_unlink (filetosign);
1414     return NULL;
1415   }
1416
1417   mutt_write_mime_header (a, sfp);
1418   fputc ('\n', sfp);
1419   mutt_write_mime_body (a, sfp);
1420   fclose (sfp);
1421
1422
1423
1424   snprintf (SmimeKeyToUse, sizeof (SmimeKeyToUse), "%s/%s",
1425            NONULL(SmimeKeys), SmimeDefaultKey);
1426
1427   snprintf (SmimeCertToUse, sizeof (SmimeCertToUse), "%s/%s",
1428            NONULL(SmimeCertificates), SmimeDefaultKey);
1429
1430   snprintf (SmimeIntermediateToUse, sizeof (SmimeIntermediateToUse), "%s/%s",
1431            NONULL(SmimeCertificates), intermediates);
1432
1433
1434
1435   if ((thepid = smime_invoke_sign (&smimein, NULL, &smimeerr,
1436                                  -1, fileno (smimeout), -1, filetosign)) == -1)
1437   {
1438     mutt_perror _("Can't open OpenSSL subprocess!");
1439     fclose (smimeout);
1440     mutt_unlink (signedfile);
1441     mutt_unlink (filetosign);
1442     return NULL;
1443   }
1444   fputs (SmimePass, smimein);
1445   fputc ('\n', smimein);
1446   fclose (smimein);
1447
1448
1449   mutt_wait_filter (thepid);
1450
1451   /* check for errors from OpenSSL */
1452   err = 0;
1453   fflush (smimeerr);
1454   rewind (smimeerr);
1455   while (fgets (buffer, sizeof (buffer) - 1, smimeerr) != NULL)
1456   {
1457     err = 1;
1458     fputs (buffer, stdout);
1459   }
1460   fclose (smimeerr);
1461
1462
1463   fflush (smimeout);
1464   rewind (smimeout);
1465   empty = (fgetc (smimeout) == EOF);
1466   fclose (smimeout);
1467
1468   mutt_unlink (filetosign);
1469
1470
1471   if (err)
1472     mutt_any_key_to_continue (NULL);
1473
1474   if (empty)
1475   {
1476     mutt_any_key_to_continue _("No output from OpenSSL...");
1477     mutt_unlink (signedfile);
1478     return (NULL); /* fatal error while signing */
1479   }
1480
1481   t = mutt_new_body ();
1482   t->type = TYPEMULTIPART;
1483   t->subtype = safe_strdup ("signed");
1484   t->encoding = ENC7BIT;
1485   t->use_disp = 0;
1486   t->disposition = DISPINLINE;
1487
1488   mutt_generate_boundary (&t->parameter);
1489   /* check if this can be extracted from private key somehow.... */
1490   mutt_set_parameter ("micalg", "sha1", &t->parameter);
1491   mutt_set_parameter ("protocol", "application/x-pkcs7-signature",
1492                      &t->parameter);
1493
1494   t->parts = a;
1495   a = t;
1496
1497   t->parts->next = mutt_new_body ();
1498   t = t->parts->next;
1499   t->type = TYPEAPPLICATION;
1500   t->subtype = safe_strdup ("x-pkcs7-signature");
1501   t->filename = safe_strdup (signedfile);
1502   t->d_filename = safe_strdup ("smime.p7s");
1503   t->use_disp = 1;
1504   t->disposition = DISPATTACH;
1505   t->encoding = ENCBASE64;
1506   t->unlink = 1; /* ok to remove this file after sending. */
1507
1508   return (a);
1509
1510 }
1511
1512
1513
1514
1515
1516
1517 /*
1518  *    Handling S/MIME - bodies.
1519  */
1520
1521
1522
1523
1524
1525
1526 static
1527 pid_t smime_invoke_verify (FILE **smimein, FILE **smimeout, FILE **smimeerr,
1528                            int smimeinfd, int smimeoutfd, int smimeerrfd,
1529                            const char *fname, const char *sig_fname, int opaque)
1530 {
1531   return smime_invoke (smimein, smimeout, smimeerr, smimeinfd, smimeoutfd,
1532                        smimeerrfd, fname, sig_fname, NULL, NULL, NULL, NULL,
1533                        (opaque ? SmimeVerifyOpaqueCommand : SmimeVerifyCommand));
1534 }
1535
1536
1537 static
1538 pid_t smime_invoke_decrypt (FILE **smimein, FILE **smimeout, FILE **smimeerr,
1539                             int smimeinfd, int smimeoutfd, int smimeerrfd,
1540                             const char *fname)
1541 {
1542   return smime_invoke (smimein, smimeout, smimeerr, smimeinfd, smimeoutfd,
1543                        smimeerrfd, fname, NULL, NULL, SmimeKeyToUse,
1544                        SmimeCertToUse, NULL, SmimeDecryptCommand);
1545 }
1546
1547
1548
1549 int smime_verify_one (BODY *sigbdy, STATE *s, const char *tempfile)
1550 {
1551   char signedfile[_POSIX_PATH_MAX], smimeerrfile[_POSIX_PATH_MAX];
1552   FILE *fp=NULL, *smimeout=NULL, *smimeerr=NULL;
1553   pid_t thepid;
1554   int badsig = -1;
1555
1556   long tmpoffset = 0;
1557   size_t tmplength = 0;
1558   int origType = sigbdy->type;
1559   char *savePrefix = NULL;
1560
1561
1562   snprintf (signedfile, sizeof (signedfile), "%s.sig", tempfile);
1563
1564   /* decode to a tempfile, saving the original destination */
1565   fp = s->fpout;
1566   if ((s->fpout = safe_fopen (signedfile, "w")) == NULL)
1567   {
1568     mutt_perror (signedfile);
1569     return -1;
1570   }
1571   /* decoding the attachment changes the size and offset, so save a copy
1572    * of the "real" values now, and restore them after processing
1573    */
1574   tmplength = sigbdy->length;
1575   tmpoffset = sigbdy->offset;
1576
1577   /* if we are decoding binary bodies, we don't want to prefix each
1578    * line with the prefix or else the data will get corrupted.
1579    */
1580   savePrefix = s->prefix;
1581   s->prefix = NULL;
1582
1583   mutt_decode_attachment (sigbdy, s);
1584
1585   sigbdy->length = ftello (s->fpout);
1586   sigbdy->offset = 0;
1587   fclose (s->fpout);
1588
1589   /* restore final destination and substitute the tempfile for input */
1590   s->fpout = fp;
1591   fp = s->fpin;
1592   s->fpin = fopen (signedfile, "r");
1593
1594   /* restore the prefix */
1595   s->prefix = savePrefix;
1596
1597   sigbdy->type = origType;
1598
1599
1600   mutt_mktemp (smimeerrfile);
1601   if (!(smimeerr = safe_fopen (smimeerrfile, "w+")))
1602   {
1603     mutt_perror (smimeerrfile);
1604     mutt_unlink (signedfile);
1605     return -1;
1606   }
1607
1608   crypt_current_time (s, "OpenSSL");
1609
1610   if ((thepid = smime_invoke_verify (NULL, &smimeout, NULL,
1611                                    -1, -1, fileno (smimeerr),
1612                                    tempfile, signedfile, 0)) != -1)
1613   {
1614     fflush (smimeout);
1615     fclose (smimeout);
1616
1617     if (mutt_wait_filter (thepid))
1618       badsig = -1;
1619     else
1620     {
1621       char *line = NULL;
1622       int lineno = 0;
1623       size_t linelen;
1624
1625       fflush (smimeerr);
1626       rewind (smimeerr);
1627
1628       line = mutt_read_line (line, &linelen, smimeerr, &lineno);
1629       if (linelen && !ascii_strcasecmp (line, "verification successful"))
1630         badsig = 0;
1631
1632       FREE (&line);
1633     }
1634   }
1635
1636   fflush (smimeerr);
1637   rewind (smimeerr);
1638   mutt_copy_stream (smimeerr, s->fpout);
1639   fclose (smimeerr);
1640
1641   state_attach_puts (_("[-- End of OpenSSL output --]\n\n"), s);
1642
1643   mutt_unlink (signedfile);
1644   mutt_unlink (smimeerrfile);
1645
1646   sigbdy->length = tmplength;
1647   sigbdy->offset = tmpoffset;
1648
1649   /* restore the original source stream */
1650   fclose (s->fpin);
1651   s->fpin = fp;
1652
1653
1654   return badsig;
1655 }
1656
1657
1658
1659
1660
1661 /*
1662   This handles application/pkcs7-mime which can either be a signed
1663   or an encrypted message.
1664 */
1665
1666 static BODY *smime_handle_entity (BODY *m, STATE *s, FILE *outFile)
1667 {
1668   int len=0;
1669   int c;
1670   long last_pos;
1671   char buf[HUGE_STRING];
1672   char outfile[_POSIX_PATH_MAX], errfile[_POSIX_PATH_MAX];
1673   char tmpfname[_POSIX_PATH_MAX];
1674   char tmptmpfname[_POSIX_PATH_MAX];
1675   FILE *smimeout = NULL, *smimein=NULL, *smimeerr=NULL;
1676   FILE *tmpfp=NULL, *tmpfp_buffer=NULL, *fpout=NULL;
1677   struct stat info;
1678   BODY *p=NULL;
1679   pid_t thepid=-1;
1680   unsigned int type = mutt_is_application_smime (m);
1681
1682   if (!(type & APPLICATION_SMIME)) return NULL;
1683
1684   mutt_mktemp (outfile);
1685   if ((smimeout = safe_fopen (outfile, "w+")) == NULL)
1686   {
1687     mutt_perror (outfile);
1688     return NULL;
1689   }
1690
1691   mutt_mktemp (errfile);
1692   if ((smimeerr = safe_fopen (errfile, "w+")) == NULL)
1693   {
1694     mutt_perror (errfile);
1695     fclose (smimeout); smimeout = NULL;
1696     return NULL;
1697   }
1698   mutt_unlink (errfile);
1699
1700
1701   mutt_mktemp (tmpfname);
1702   if ((tmpfp = safe_fopen (tmpfname, "w+")) == NULL)
1703   {
1704     mutt_perror (tmpfname);
1705     fclose (smimeout); smimeout = NULL;
1706     fclose (smimeerr); smimeerr = NULL;
1707     return NULL;
1708   }
1709
1710   fseeko (s->fpin, m->offset, 0);
1711   last_pos = m->offset;
1712
1713   mutt_copy_bytes (s->fpin, tmpfp,  m->length);
1714
1715   fflush (tmpfp);
1716   fclose (tmpfp);
1717
1718   if ((type & ENCRYPT) &&
1719       (thepid = smime_invoke_decrypt (&smimein, NULL, NULL, -1,
1720                                       fileno (smimeout),  fileno (smimeerr), tmpfname)) == -1)
1721   {
1722     fclose (smimeout); smimeout = NULL;
1723     mutt_unlink (tmpfname);
1724     if (s->flags & M_DISPLAY)
1725       state_attach_puts (_("[-- Error: unable to create OpenSSL subprocess! --]\n"), s);
1726     return NULL;
1727   }
1728   else if ((type & SIGNOPAQUE) &&
1729            (thepid = smime_invoke_verify (&smimein, NULL, NULL, -1,
1730                                           fileno (smimeout), fileno (smimeerr), NULL,
1731                                           tmpfname, SIGNOPAQUE)) == -1)
1732   {
1733     fclose (smimeout); smimeout = NULL;
1734     mutt_unlink (tmpfname);
1735     if (s->flags & M_DISPLAY)
1736       state_attach_puts (_("[-- Error: unable to create OpenSSL subprocess! --]\n"), s);
1737     return NULL;
1738   }
1739
1740
1741   if (type & ENCRYPT)
1742   {
1743     if (!smime_valid_passphrase ())
1744       smime_void_passphrase ();
1745     fputs (SmimePass, smimein);
1746     fputc ('\n', smimein);
1747   }
1748
1749   fclose (smimein);
1750
1751   mutt_wait_filter (thepid);
1752   mutt_unlink (tmpfname);
1753
1754
1755   if (s->flags & M_DISPLAY)
1756   {
1757     fflush (smimeerr);
1758     rewind (smimeerr);
1759
1760     if ((c = fgetc (smimeerr)) != EOF)
1761     {
1762       ungetc (c, smimeerr);
1763
1764       crypt_current_time (s, "OpenSSL");
1765       mutt_copy_stream (smimeerr, s->fpout);
1766       state_attach_puts (_("[-- End of OpenSSL output --]\n\n"), s);
1767     }
1768
1769     if (type & ENCRYPT)
1770       state_attach_puts (_("[-- The following data is S/MIME"
1771                            " encrypted --]\n"), s);
1772     else
1773       state_attach_puts (_("[-- The following data is S/MIME signed --]\n"), s);
1774   }
1775
1776   if (smimeout)
1777   {
1778     fflush (smimeout);
1779     rewind (smimeout);
1780
1781     if (outFile) fpout = outFile;
1782     else
1783     {
1784       mutt_mktemp (tmptmpfname);
1785       if ((fpout = safe_fopen (tmptmpfname, "w+")) == NULL)
1786       {
1787         mutt_perror(tmptmpfname);
1788         fclose (smimeout); smimeout = NULL;
1789         return NULL;
1790       }
1791     }
1792     while (fgets (buf, sizeof (buf) - 1, smimeout) != NULL)
1793     {
1794       len = mutt_strlen (buf);
1795       if (len > 1 && buf[len - 2] == '\r')
1796       {
1797         buf[len-2] = '\n';
1798         buf[len-1] = '\0';
1799       }
1800       fputs (buf, fpout);
1801     }
1802     fflush (fpout);
1803     rewind (fpout);
1804
1805
1806     if ((p = mutt_read_mime_header (fpout, 0)) != NULL)
1807     {
1808       fstat (fileno (fpout), &info);
1809       p->length = info.st_size - p->offset;
1810
1811       mutt_parse_part (fpout, p);
1812       if (s->fpout)
1813       {
1814         rewind (fpout);
1815         tmpfp_buffer = s->fpin;
1816         s->fpin = fpout;
1817         mutt_body_handler (p, s);
1818         s->fpin = tmpfp_buffer;
1819       }
1820
1821     }
1822     fclose (smimeout);
1823     smimeout = NULL;
1824     mutt_unlink (outfile);
1825
1826     if (!outFile)
1827     {
1828       fclose (fpout);
1829       mutt_unlink (tmptmpfname);
1830     }
1831     fpout = NULL;
1832   }
1833
1834   if (s->flags & M_DISPLAY)
1835   {
1836     if (type & ENCRYPT)
1837       state_attach_puts (_("\n[-- End of S/MIME encrypted data. --]\n"), s);
1838     else
1839       state_attach_puts (_("\n[-- End of S/MIME signed data. --]\n"), s);
1840   }
1841
1842   if (type & SIGNOPAQUE)
1843   {
1844     char *line = NULL;
1845     int lineno = 0;
1846     size_t linelen;
1847
1848     rewind (smimeerr);
1849
1850     line = mutt_read_line (line, &linelen, smimeerr, &lineno);
1851     if (linelen && !ascii_strcasecmp (line, "verification successful"))
1852       m->goodsig = 1;
1853     FREE (&line);
1854   }
1855   else
1856   {
1857     m->goodsig = p->goodsig;
1858     m->badsig  = p->badsig;
1859   }
1860   fclose (smimeerr);
1861
1862   return (p);
1863 }
1864
1865
1866
1867
1868
1869 int smime_decrypt_mime (FILE *fpin, FILE **fpout, BODY *b, BODY **cur)
1870 {
1871
1872
1873   char tempfile[_POSIX_PATH_MAX];
1874   STATE s;
1875   long tmpoffset = b->offset;
1876   size_t tmplength = b->length;
1877   int origType = b->type;
1878   FILE *tmpfp=NULL;
1879   int rv = 0;
1880
1881   if (!mutt_is_application_smime (b))
1882     return -1;
1883
1884   if (b->parts)
1885     return -1;
1886
1887   memset (&s, 0, sizeof (s));
1888   s.fpin = fpin;
1889   fseeko (s.fpin, b->offset, 0);
1890
1891   mutt_mktemp (tempfile);
1892   if ((tmpfp = safe_fopen (tempfile, "w+")) == NULL)
1893   {
1894     mutt_perror (tempfile);
1895     return (-1);
1896   }
1897
1898   mutt_unlink (tempfile);
1899   s.fpout = tmpfp;
1900   mutt_decode_attachment (b, &s);
1901   fflush (tmpfp);
1902   b->length = ftello (s.fpout);
1903   b->offset = 0;
1904   rewind (tmpfp);
1905   s.fpin = tmpfp;
1906   s.fpout = 0;
1907
1908   mutt_mktemp (tempfile);
1909   if ((*fpout = safe_fopen (tempfile, "w+")) == NULL)
1910   {
1911     mutt_perror (tempfile);
1912     rv = -1;
1913     goto bail;
1914   }
1915   mutt_unlink (tempfile);
1916
1917   if (!(*cur = smime_handle_entity (b, &s, *fpout)))
1918   {
1919     rv = -1;
1920     goto bail;
1921   }
1922
1923   (*cur)->goodsig = b->goodsig;
1924   (*cur)->badsig  = b->badsig;
1925
1926 bail:
1927   b->type = origType;
1928   b->length = tmplength;
1929   b->offset = tmpoffset;
1930   safe_fclose (&tmpfp);
1931   if (*fpout)
1932     rewind (*fpout);
1933
1934   return rv;
1935 }
1936
1937
1938 int smime_application_smime_handler (BODY *m, STATE *s)
1939 {
1940   return smime_handle_entity (m, s, NULL) ? 0 : -1;
1941 }
1942
1943 int smime_send_menu (HEADER *msg, int *redraw)
1944 {
1945   char *p;
1946
1947   if (!(WithCrypto & APPLICATION_SMIME))
1948     return msg->security;
1949
1950   switch (mutt_multi_choice (_("S/MIME (e)ncrypt, (s)ign, encrypt (w)ith, sign (a)s, (b)oth, or (c)lear? "),
1951                              _("eswabfc")))
1952   {
1953   case 1: /* (e)ncrypt */
1954     msg->security |= ENCRYPT;
1955     msg->security &= ~SIGN;
1956     break;
1957
1958   case 3: /* encrypt (w)ith */
1959     {
1960       int choice = 0;
1961
1962       msg->security |= ENCRYPT;
1963       do
1964       {
1965         /* I use "dra" because "123" is recognized anyway */
1966         switch (mutt_multi_choice (_("Choose algorithm family:"
1967                                      " 1: DES, 2: RC2, 3: AES,"
1968                                      " or (c)lear? "),
1969                                    _("drac")))
1970         {
1971         case 1:
1972           switch (choice = mutt_multi_choice (_("1: DES, 2: Triple-DES "),
1973                                               _("dt")))
1974           {
1975           case 1:
1976             mutt_str_replace (&SmimeCryptAlg, "des");
1977             break;
1978           case 2:
1979             mutt_str_replace (&SmimeCryptAlg, "des3");
1980             break;
1981           }
1982           break;
1983
1984         case 2:
1985           switch (choice = mutt_multi_choice (_("1: RC2-40, 2: RC2-64, 3: RC2-128 "),
1986                                               _("468")))
1987           {
1988           case 1:
1989             mutt_str_replace (&SmimeCryptAlg, "rc2-40");
1990             break;
1991           case 2:
1992             mutt_str_replace (&SmimeCryptAlg, "rc2-64");
1993             break;
1994           case 3:
1995             mutt_str_replace (&SmimeCryptAlg, "rc2-128");
1996             break;
1997           }
1998           break;
1999
2000         case 3:
2001           switch (choice = mutt_multi_choice (_("1: AES128, 2: AES192, 3: AES256 "),
2002                                               _("895")))
2003           {
2004           case 1:
2005             mutt_str_replace (&SmimeCryptAlg, "aes128");
2006             break;
2007           case 2:
2008             mutt_str_replace (&SmimeCryptAlg, "aes192");
2009             break;
2010           case 3:
2011             mutt_str_replace (&SmimeCryptAlg, "aes256");
2012             break;
2013           }
2014           break;
2015
2016         case 4: /* (c)lear */
2017           FREE (&SmimeCryptAlg);
2018           /* fallback */
2019         case -1: /* Ctrl-G or Enter */
2020           choice = 0;
2021           break;
2022         }
2023       } while (choice == -1);
2024     }
2025     break;
2026
2027   case 2: /* (s)ign */
2028
2029     if(!SmimeDefaultKey)
2030     {
2031       *redraw = REDRAW_FULL;
2032
2033       if ((p = smime_ask_for_key (_("Sign as: "), NULL, 0)))
2034         mutt_str_replace (&SmimeDefaultKey, p);
2035       else
2036         break;
2037     }
2038
2039     msg->security |= SIGN;
2040     msg->security &= ~ENCRYPT;
2041     break;
2042
2043   case 4: /* sign (a)s */
2044
2045     if ((p = smime_ask_for_key (_("Sign as: "), NULL, 0)))
2046     {
2047       mutt_str_replace (&SmimeDefaultKey, p);
2048
2049       msg->security |= SIGN;
2050
2051       /* probably need a different passphrase */
2052       crypt_smime_void_passphrase ();
2053     }
2054 #if 0
2055     else
2056       msg->security &= ~SIGN;
2057 #endif
2058
2059     *redraw = REDRAW_FULL;
2060     break;
2061
2062   case 5: /* (b)oth */
2063     msg->security |= (ENCRYPT | SIGN);
2064     break;
2065
2066   case 6: /* (f)orget it */
2067   case 7: /* (c)lear */
2068     msg->security = 0;
2069     break;
2070   }
2071
2072   if (msg->security && msg->security != APPLICATION_SMIME)
2073     msg->security |= APPLICATION_SMIME;
2074   else
2075     msg->security = 0;
2076
2077   return (msg->security);
2078 }
2079
2080
2081 #endif /* CRYPT_BACKEND_CLASSIC_SMIME */