lib-crypt/crypt-gpgme.c

   1 /*
   2  * Copyright notice from original mutt:
   3  * crypt-gpgme.c - GPGME based crypto operations
   4  * Copyright (C) 1996,1997 Michael R. Elkins <me@cs.hmc.edu>
   5  * Copyright (C) 1998,1999,2000 Thomas Roessler <roessler@guug.de>
   6  * Copyright (C) 2001  Thomas Roessler <roessler@guug.de>
   7  *                     Oliver Ehli <elmy@acm.org>
   8  * Copyright (C) 2002, 2003, 2004 g10 Code GmbH
   9  *
  10  * This file is part of mutt-ng, see http://www.muttng.org/.
  11  * It's licensed under the GNU General Public License,
  12  * please see the file GPL in the top level source directory.
  13  */
  14
  15 #include <lib-lib/lib-lib.h>
  16
  17 #ifdef CRYPT_BACKEND_GPGME
  18
  19 #ifdef HAVE_LOCALE_H
  20 #  include <locale.h>
  21 #endif
  22 #ifdef HAVE_LANGINFO_D_T_FMT
  23 #  include <langinfo.h>
  24 #endif
  25 #ifdef HAVE_SYS_RESOURCE_H
  26 #  include <sys/resource.h>
  27 #endif
  28
  29 #include <gpgme.h>
  30
  31 #include <lib-mime/mime.h>
  32
  33 #include <lib-ui/curses.h>
  34 #include <lib-ui/enter.h>
  35 #include <lib-ui/menu.h>
  36
  37 #include "lib.h"
  38 #include "alias.h"
  39 #include <lib-crypt/crypt.h>
  40 #include "handler.h"
  41 #include "copy.h"
  42 #include "pager.h"
  43 #include "recvattach.h"
  44 #include "sort.h"
  45 #include "crypt-gpgme.h"
  46
  47 /*
  48  * Helper macros.
  49  */
  50 #define digitp(p)   (*(p) >= '0' && *(p) <= '9')
  51 #define hexdigitp(a) (digitp (a)                     \
  52                       || (*(a) >= 'A' && *(a) <= 'F')  \
  53                       || (*(a) >= 'a' && *(a) <= 'f'))
  54 #define xtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): \
  55                      *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
  56 #define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))
  57
  58 /* Values used for comparing addresses. */
  59 #define CRYPT_KV_VALID    1
  60 #define CRYPT_KV_ADDR     2
  61 #define CRYPT_KV_STRING   4
  62 #define CRYPT_KV_STRONGID 8
  63 #define CRYPT_KV_MATCH (CRYPT_KV_ADDR|CRYPT_KV_STRING)
  64
  65 /*
  66  * Type definitions.
  67  */
  68
  69 struct crypt_cache {
  70   char *what;
  71   char *dflt;
  72   struct crypt_cache *next;
  73 };
  74
  75 struct dn_array_s {
  76   char *key;
  77   char *value;
  78 };
  79
  80 /* We work based on user IDs, getting from a user ID to the key is
  81    check and does not need any memory (gpgme uses reference counting). */
  82 typedef struct crypt_keyinfo {
  83   struct crypt_keyinfo *next;
  84   gpgme_key_t kobj;
  85   int idx;                      /* and the user ID at this index */
  86   const char *uid;              /* and for convenience point to this user ID */
  87   unsigned int flags;           /* global and per uid flags (for convenience) */
  88 } crypt_key_t;
  89
  90 typedef struct crypt_entry {
  91   ssize_t num;
  92   crypt_key_t *key;
  93 } crypt_entry_t;
  94
  95
  96 static struct crypt_cache *id_defaults = NULL;
  97 static gpgme_key_t signature_key = NULL;
  98
  99 /*
 100  * General helper functions.
 101  */
 102
 103 /* return true when S points to a didgit or letter. */
 104 static int digit_or_letter (const unsigned char *s)
 105 {
 106   return ((*s >= '0' && *s <= '9')
 107           || (*s >= 'A' && *s <= 'Z')
 108           || (*s >= 'a' && *s <= 'z'));
 109 }
 110
 111
 112 /* Print the utf-8 encoded string BUF of length LEN bytes to stream
 113    FP. Convert the character set. */
 114 static void print_utf8 (FILE * fp, const char *buf, ssize_t len)
 115 {
 116   char *tstr;
 117
 118   tstr = p_dupstr(buf, len);
 119   mutt_convert_string (&tstr, "utf-8", Charset, M_ICONV_HOOK_FROM);
 120   fputs (tstr, fp);
 121   p_delete(&tstr);
 122 }
 123
 124
 125 /*
 126  * Key management.
 127  */
 128
 129 /* Return the keyID for the key K.  Note that this string is valid as
 130    long as K is valid */
 131 static const char *crypt_keyid (crypt_key_t * k)
 132 {
 133   const char *s = "????????";
 134
 135   if (k->kobj && k->kobj->subkeys) {
 136     s = k->kobj->subkeys->keyid;
 137     if ((!option (OPTPGPLONGIDS)) && (m_strlen(s) == 16))
 138       /* Return only the short keyID.  */
 139       s += 8;
 140   }
 141
 142   return s;
 143 }
 144
 145 /* Return the hexstring fingerprint from the key K. */
 146 static const char *crypt_fpr (crypt_key_t * k)
 147 {
 148   const char *s = "";
 149
 150   if (k->kobj && k->kobj->subkeys)
 151     s = k->kobj->subkeys->fpr;
 152
 153   return s;
 154 }
 155
 156 /* Parse FLAGS and return a statically allocated(!) string with them. */
 157 static char *crypt_key_abilities (int flags)
 158 {
 159   static char buff[3];
 160
 161   if (!(flags & KEYFLAG_CANENCRYPT))
 162     buff[0] = '-';
 163   else if (flags & KEYFLAG_PREFER_SIGNING)
 164     buff[0] = '.';
 165   else
 166     buff[0] = 'e';
 167
 168   if (!(flags & KEYFLAG_CANSIGN))
 169     buff[1] = '-';
 170   else if (flags & KEYFLAG_PREFER_ENCRYPTION)
 171     buff[1] = '.';
 172   else
 173     buff[1] = 's';
 174
 175   buff[2] = '\0';
 176
 177   return buff;
 178 }
 179
 180 /* Parse FLAGS and return a character describing the most important flag. */
 181 static char crypt_flags (int flags)
 182 {
 183   if (flags & KEYFLAG_REVOKED)
 184     return 'R';
 185   else if (flags & KEYFLAG_EXPIRED)
 186     return 'X';
 187   else if (flags & KEYFLAG_DISABLED)
 188     return 'd';
 189   else if (flags & KEYFLAG_CRITICAL)
 190     return 'c';
 191   else
 192     return ' ';
 193 }
 194
 195 /* Return a copy of KEY. */
 196 static crypt_key_t *crypt_copy_key (crypt_key_t *key)
 197 {
 198   crypt_key_t *k;
 199
 200   k = p_new(crypt_key_t, 1);
 201   k->kobj = key->kobj;
 202   gpgme_key_ref (key->kobj);
 203   k->idx = key->idx;
 204   k->uid = key->uid;
 205   k->flags = key->flags;
 206
 207   return k;
 208 }
 209
 210 /* Release all the keys at the address of KEYLIST and set the address
 211    to NULL. */
 212 static void crypt_free_key (crypt_key_t ** keylist)
 213 {
 214   while (*keylist) {
 215     crypt_key_t *k = (*keylist)->next;
 216
 217     p_delete(&k);
 218     *keylist = k;
 219   }
 220 }
 221
 222 /* Return trute when key K is valid. */
 223 static int crypt_key_is_valid (crypt_key_t * k)
 224 {
 225   if (k->flags & KEYFLAG_CANTUSE)
 226     return 0;
 227   return 1;
 228 }
 229
 230 /* Return true whe validity of KEY is sufficient. */
 231 static int crypt_id_is_strong (crypt_key_t * key)
 232 {
 233   gpgme_validity_t val = GPGME_VALIDITY_UNKNOWN;
 234   gpgme_user_id_t uid = NULL;
 235   int is_strong = 0;
 236   int i = 0;
 237
 238   if ((key->flags & KEYFLAG_ISX509))
 239     return 1;
 240
 241   for (i = 0, uid = key->kobj->uids; (i < key->idx) && uid;
 242        i++, uid = uid->next);
 243   if (uid)
 244     val = uid->validity;
 245
 246   switch (val) {
 247   case GPGME_VALIDITY_UNKNOWN:
 248   case GPGME_VALIDITY_UNDEFINED:
 249   case GPGME_VALIDITY_NEVER:
 250   case GPGME_VALIDITY_MARGINAL:
 251     is_strong = 0;
 252     break;
 253
 254   case GPGME_VALIDITY_FULL:
 255   case GPGME_VALIDITY_ULTIMATE:
 256     is_strong = 1;
 257     break;
 258   }
 259
 260   return is_strong;
 261 }
 262
 263 /* Return true when the KEY is valid, i.e. not marked as unusable. */
 264 static int crypt_id_is_valid (crypt_key_t * key)
 265 {
 266   return !(key->flags & KEYFLAG_CANTUSE);
 267 }
 268
 269 /* Return a bit vector describing how well the addresses ADDR and
 270    U_ADDR match and whether KEY is valid. */
 271 static int crypt_id_matches_addr (address_t * addr, address_t * u_addr,
 272                                   crypt_key_t * key)
 273 {
 274   int rv = 0;
 275
 276   if (crypt_id_is_valid (key))
 277     rv |= CRYPT_KV_VALID;
 278
 279   if (crypt_id_is_strong (key))
 280     rv |= CRYPT_KV_STRONGID;
 281
 282   if (addr->mailbox && u_addr->mailbox
 283       && m_strcasecmp(addr->mailbox, u_addr->mailbox) == 0)
 284     rv |= CRYPT_KV_ADDR;
 285
 286   if (addr->personal && u_addr->personal
 287       && m_strcasecmp(addr->personal, u_addr->personal) == 0)
 288     rv |= CRYPT_KV_STRING;
 289
 290   return rv;
 291 }
 292
 293
 294 /*
 295  * GPGME convenient functions.
 296  */
 297
 298 /* Create a new gpgme context and return it.  With FOR_SMIME set to
 299    true, the protocol of the context is set to CMS. */
 300 static gpgme_ctx_t create_gpgme_context (int for_smime)
 301 {
 302   gpgme_error_t err;
 303   gpgme_ctx_t ctx;
 304
 305   err = gpgme_new (&ctx);
 306   if (err) {
 307     mutt_error (_("error creating gpgme context: %s\n"), gpgme_strerror (err));
 308     sleep (2);
 309     mutt_exit (1);
 310   }
 311
 312   if (for_smime) {
 313     err = gpgme_set_protocol (ctx, GPGME_PROTOCOL_CMS);
 314     if (err) {
 315       mutt_error (_("error enabling CMS protocol: %s\n"), gpgme_strerror (err));
 316       sleep (2);
 317       mutt_exit (1);
 318     }
 319   }
 320
 321   return ctx;
 322 }
 323
 324 /* Create a new gpgme data object.  This is a wrapper to die on
 325    error. */
 326 static gpgme_data_t create_gpgme_data (void)
 327 {
 328   gpgme_error_t err;
 329   gpgme_data_t data;
 330
 331   err = gpgme_data_new (&data);
 332   if (err) {
 333     mutt_error (_("error creating gpgme data object: %s\n"),
 334                 gpgme_strerror (err));
 335     sleep (2);
 336     mutt_exit (1);
 337   }
 338   return data;
 339 }
 340
 341 /* Create a new GPGME Data object from the mail body A.  With CONVERT
 342    passed as true, the lines are converted to CR,LF if required.
 343    Return NULL on error or the gpgme_data_t object on success. */
 344 static gpgme_data_t body_to_data_object (BODY * a, int convert)
 345 {
 346   char tempfile[_POSIX_PATH_MAX];
 347   FILE *fptmp;
 348   int err = 0;
 349   gpgme_data_t data;
 350
 351   fptmp = m_tempfile(tempfile, sizeof(tempfile), NONULL(Tempdir), NULL);
 352   if (!fptmp) {
 353     mutt_perror (_("Can't create temporary file"));
 354     return NULL;
 355   }
 356
 357   mutt_write_mime_header (a, fptmp);
 358   fputc ('\n', fptmp);
 359   mutt_write_mime_body (a, fptmp);
 360
 361   if (convert) {
 362     int c, hadcr = 0;
 363     unsigned char buf[1];
 364
 365     data = create_gpgme_data ();
 366     rewind (fptmp);
 367     while ((c = fgetc (fptmp)) != EOF) {
 368       if (c == '\r')
 369         hadcr = 1;
 370       else {
 371         if (c == '\n' && !hadcr) {
 372           buf[0] = '\r';
 373           gpgme_data_write (data, buf, 1);
 374         }
 375
 376         hadcr = 0;
 377       }
 378       /* FIXME: This is quite suboptimal */
 379       buf[0] = c;
 380       gpgme_data_write (data, buf, 1);
 381     }
 382     gpgme_data_seek (data, 0, SEEK_SET);
 383   } else {
 384     err = gpgme_data_new_from_file (&data, tempfile, 1);
 385   }
 386   m_fclose(&fptmp);
 387   unlink (tempfile);
 388   if (err) {
 389     mutt_error (_("error allocating data object: %s\n"), gpgme_strerror (err));
 390     return NULL;
 391   }
 392
 393   return data;
 394 }
 395
 396 /* Create a GPGME data object from the stream FP but limit the object
 397    to LENGTH bytes starting at OFFSET bytes from the beginning of the
 398    file. */
 399 static gpgme_data_t file_to_data_object (FILE * fp, long offset, long length)
 400 {
 401   int err = 0;
 402   gpgme_data_t data;
 403
 404   err = gpgme_data_new_from_filepart (&data, NULL, fp, offset, length);
 405   if (err) {
 406     mutt_error (_("error allocating data object: %s\n"), gpgme_strerror (err));
 407     return NULL;
 408   }
 409
 410   return data;
 411 }
 412
 413 /* Write a GPGME data object to the stream FP. */
 414 static int data_object_to_stream (gpgme_data_t data, FILE * fp)
 415 {
 416   int err;
 417   char buf[4096], *p;
 418   ssize_t nread;
 419
 420   err = ((gpgme_data_seek (data, 0, SEEK_SET) == -1)
 421          ? gpgme_error_from_errno (errno) : 0);
 422   if (err) {
 423     mutt_error (_("error rewinding data object: %s\n"), gpgme_strerror (err));
 424     return -1;
 425   }
 426
 427   while ((nread = gpgme_data_read (data, buf, sizeof (buf)))) {
 428     /* fixme: we are not really converting CRLF to LF but just
 429        skipping CR. Doing it correctly needs a more complex logic */
 430     for (p = buf; nread; p++, nread--) {
 431       if (*p != '\r')
 432         putc (*p, fp);
 433     }
 434
 435     if (ferror (fp)) {
 436       mutt_perror ("[tempfile]");
 437       return -1;
 438     }
 439   }
 440   if (nread == -1) {
 441     mutt_error (_("error reading data object: %s\n"), strerror (errno));
 442     return -1;
 443   }
 444   return 0;
 445 }
 446
 447 /* Copy a data object to a newly created temporay file and return that
 448    filename. Caller must free.  With RET_FP not NULL, don't close the
 449    stream but return it there. */
 450 static char *data_object_to_tempfile (gpgme_data_t data, FILE ** ret_fp)
 451 {
 452   int err;
 453   char tempfile[_POSIX_PATH_MAX];
 454   FILE *fp;
 455   ssize_t nread = 0;
 456
 457   fp = m_tempfile(tempfile, sizeof(tempfile), NONULL(Tempdir), NULL);
 458   if (!fp) {
 459     mutt_perror (_("Can't create temporary file"));
 460     return NULL;
 461   }
 462
 463   err = ((gpgme_data_seek (data, 0, SEEK_SET) == -1)
 464          ? gpgme_error_from_errno (errno) : 0);
 465   if (!err) {
 466     char buf[4096];
 467
 468     while ((nread = gpgme_data_read (data, buf, sizeof (buf)))) {
 469       if (fwrite (buf, nread, 1, fp) != 1) {
 470         mutt_perror (_("Can't create temporary file"));
 471         m_fclose(&fp);
 472         unlink (tempfile);
 473         return NULL;
 474       }
 475     }
 476   }
 477   if (ret_fp)
 478     rewind (fp);
 479   else
 480     m_fclose(&fp);
 481   if (nread == -1) {
 482     mutt_error (_("error reading data object: %s\n"), gpgme_strerror (err));
 483     unlink (tempfile);
 484     m_fclose(&fp);
 485     return NULL;
 486   }
 487   if (ret_fp)
 488     *ret_fp = fp;
 489   return m_strdup(tempfile);
 490 }
 491
 492
 493 /* Create a GpgmeRecipientSet from the keys in the string KEYLIST.
 494    The keys must be space delimited. */
 495 static gpgme_key_t *create_recipient_set (const char *keylist,
 496                                           gpgme_protocol_t protocol)
 497 {
 498   int err;
 499   const char *s;
 500   char buf[100];
 501   int i;
 502   gpgme_key_t *rset = NULL;
 503   unsigned int rset_n = 0;
 504   gpgme_key_t key = NULL;
 505   gpgme_ctx_t context = NULL;
 506
 507   err = gpgme_new (&context);
 508   if (!err)
 509     err = gpgme_set_protocol (context, protocol);
 510
 511   if (!err) {
 512     s = keylist;
 513     do {
 514       while (*s == ' ')
 515         s++;
 516       for (i = 0; *s && *s != ' ' && i < ssizeof(buf) - 1;)
 517         buf[i++] = *s++;
 518       buf[i] = 0;
 519       if (*buf) {
 520         if (i > 1 && buf[i - 1] == '!') {
 521           /* The user selected to override the valididy of that
 522              key. */
 523           buf[i - 1] = 0;
 524
 525           err = gpgme_get_key (context, buf, &key, 0);
 526           if (!err)
 527             key->uids->validity = GPGME_VALIDITY_FULL;
 528           buf[i - 1] = '!';
 529         }
 530         else
 531           err = gpgme_get_key (context, buf, &key, 0);
 532
 533         if (!err) {
 534           p_realloc(&rset, rset_n + 1);
 535           rset[rset_n++] = key;
 536         }
 537         else {
 538           mutt_error (_("error adding recipient `%s': %s\n"),
 539                       buf, gpgme_strerror (err));
 540           p_delete(&rset);
 541           return NULL;
 542         }
 543       }
 544     } while (*s);
 545   }
 546
 547   /* NULL terminate.  */
 548   p_realloc(&rset, rset_n + 1);
 549   rset[rset_n++] = NULL;
 550
 551   if (context)
 552     gpgme_release (context);
 553
 554   return rset;
 555 }
 556
 557
 558 /* Make sure that the correct signer is set. Returns 0 on success. */
 559 static int set_signer (gpgme_ctx_t ctx, int for_smime)
 560 {
 561   char *signid = for_smime ? SmimeDefaultKey : PgpSignAs;
 562   gpgme_error_t err;
 563   gpgme_ctx_t listctx;
 564   gpgme_key_t key, key2;
 565
 566   if (!signid || !*signid)
 567     return 0;
 568
 569   listctx = create_gpgme_context (for_smime);
 570   err = gpgme_op_keylist_start (listctx, signid, 1);
 571   if (!err)
 572     err = gpgme_op_keylist_next (listctx, &key);
 573   if (err) {
 574     gpgme_release (listctx);
 575     mutt_error (_("secret key `%s' not found: %s\n"),
 576                 signid, gpgme_strerror (err));
 577     return -1;
 578   }
 579   err = gpgme_op_keylist_next (listctx, &key2);
 580   if (!err) {
 581     gpgme_key_release (key);
 582     gpgme_key_release (key2);
 583     gpgme_release (listctx);
 584     mutt_error (_("ambiguous specification of secret key `%s'\n"), signid);
 585     return -1;
 586   }
 587   gpgme_op_keylist_end (listctx);
 588   gpgme_release (listctx);
 589
 590   gpgme_signers_clear (ctx);
 591   err = gpgme_signers_add (ctx, key);
 592   gpgme_key_release (key);
 593   if (err) {
 594     mutt_error (_("error setting secret key `%s': %s\n"),
 595                 signid, gpgme_strerror (err));
 596     return -1;
 597   }
 598   return 0;
 599 }
 600
 601
 602 /* Encrypt the gpgme data object PLAINTEXT to the recipients in RSET
 603    and return an allocated filename to a temporary file containing the
 604    enciphered text.  With USE_SMIME set to true, the smime backend is
 605    used.  With COMBINED_SIGNED a PGP message is signed and
 606    encrypted.  Returns NULL in case of error */
 607 static char *encrypt_gpgme_object (gpgme_data_t plaintext, gpgme_key_t * rset,
 608                                    int use_smime, int combined_signed)
 609 {
 610   int err;
 611   gpgme_ctx_t ctx;
 612   gpgme_data_t ciphertext;
 613   char *outfile;
 614
 615   ctx = create_gpgme_context (use_smime);
 616   if (!use_smime)
 617     gpgme_set_armor (ctx, 1);
 618
 619   ciphertext = create_gpgme_data ();
 620
 621   if (combined_signed) {
 622     if (set_signer (ctx, use_smime)) {
 623       gpgme_data_release (ciphertext);
 624       gpgme_release (ctx);
 625       return NULL;
 626     }
 627     err = gpgme_op_encrypt_sign (ctx, rset, GPGME_ENCRYPT_ALWAYS_TRUST,
 628                                  plaintext, ciphertext);
 629   }
 630   else
 631     err = gpgme_op_encrypt (ctx, rset, GPGME_ENCRYPT_ALWAYS_TRUST,
 632                             plaintext, ciphertext);
 633   mutt_need_hard_redraw ();
 634   if (err) {
 635     mutt_error (_("error encrypting data: %s\n"), gpgme_strerror (err));
 636     gpgme_data_release (ciphertext);
 637     gpgme_release (ctx);
 638     return NULL;
 639   }
 640
 641   gpgme_release (ctx);
 642
 643   outfile = data_object_to_tempfile (ciphertext, NULL);
 644   gpgme_data_release (ciphertext);
 645   return outfile;
 646 }
 647
 648 /* Find the "micalg" parameter from the last Gpgme operation on
 649    context CTX.  It is expected that this operation was a sign
 650    operation.  Return the algorithm name as a C string in buffer BUF
 651    which must have been allocated by the caller with size BUFLEN.
 652    Returns 0 on success or -1 in case of an error.  The return string
 653    is truncted to BUFLEN - 1. */
 654 static int get_micalg (gpgme_ctx_t ctx, char *buf, ssize_t buflen)
 655 {
 656   gpgme_sign_result_t result = NULL;
 657   const char *algorithm_name = NULL;
 658
 659   if (!buflen)
 660     return -1;
 661
 662   *buf = 0;
 663   result = gpgme_op_sign_result (ctx);
 664   if (result) {
 665     algorithm_name = gpgme_hash_algo_name (result->signatures->hash_algo);
 666     if (algorithm_name) {
 667       m_strcpy(buf, buflen, algorithm_name);
 668     }
 669   }
 670
 671   return *buf ? 0 : -1;
 672 }
 673
 674 static void print_time (time_t t, STATE * s)
 675 {
 676   char p[STRING];
 677
 678   setlocale (LC_TIME, "");
 679 #ifdef HAVE_LANGINFO_D_T_FMT
 680   strftime (p, sizeof (p), nl_langinfo (D_T_FMT), localtime (&t));
 681 #else
 682   strftime (p, sizeof (p), "%c", localtime (&t));
 683 #endif
 684   setlocale (LC_TIME, "C");
 685   state_attach_puts (p, s);
 686 }
 687
 688 /*
 689  * Implementation of `sign_message'.
 690  */
 691
 692 /* Sign the MESSAGE in body A either using OpenPGP or S/MIME when
 693    USE_SMIME is passed as true.  Returns the new body or NULL on
 694    error. */
 695 static BODY *sign_message (BODY * a, int use_smime)
 696 {
 697   BODY *t;
 698   char *sigfile;
 699   int err = 0;
 700   char buf[100];
 701   gpgme_ctx_t ctx;
 702   gpgme_data_t message, signature;
 703
 704   convert_to_7bit (a);          /* Signed data _must_ be in 7-bit format. */
 705
 706   message = body_to_data_object (a, 1);
 707   if (!message)
 708     return NULL;
 709   signature = create_gpgme_data ();
 710
 711   ctx = create_gpgme_context (use_smime);
 712   if (!use_smime)
 713     gpgme_set_armor (ctx, 1);
 714
 715   if (set_signer (ctx, use_smime)) {
 716     gpgme_data_release (signature);
 717     gpgme_release (ctx);
 718     return NULL;
 719   }
 720
 721   err = gpgme_op_sign (ctx, message, signature, GPGME_SIG_MODE_DETACH);
 722   mutt_need_hard_redraw ();
 723   gpgme_data_release (message);
 724   if (err) {
 725     gpgme_data_release (signature);
 726     gpgme_release (ctx);
 727     mutt_error (_("error signing data: %s\n"), gpgme_strerror (err));
 728     return NULL;
 729   }
 730
 731   sigfile = data_object_to_tempfile (signature, NULL);
 732   gpgme_data_release (signature);
 733   if (!sigfile) {
 734     gpgme_release (ctx);
 735     return NULL;
 736   }
 737
 738   t = body_new();
 739   t->type = TYPEMULTIPART;
 740   t->subtype = m_strdup("signed");
 741   t->encoding = ENC7BIT;
 742   t->use_disp = 0;
 743   t->disposition = DISPINLINE;
 744
 745   parameter_set_boundary(&t->parameter);
 746   parameter_setval(&t->parameter, "protocol",
 747                    use_smime ? "application/pkcs7-signature"
 748                              : "application/pgp-signature");
 749   /* Get the micalg from gpgme.  Old gpgme versions don't support this
 750      for S/MIME so we assume sha-1 in this case. */
 751   if (!get_micalg (ctx, buf, sizeof buf))
 752     parameter_setval(&t->parameter, "micalg", buf);
 753   else if (use_smime)
 754     parameter_setval(&t->parameter, "micalg", "sha1");
 755   gpgme_release (ctx);
 756
 757   t->parts = a;
 758   a = t;
 759
 760   t->parts->next = body_new();
 761   t = t->parts->next;
 762   t->type = TYPEAPPLICATION;
 763   if (use_smime) {
 764     t->subtype = m_strdup("pkcs7-signature");
 765     parameter_setval(&t->parameter, "name", "smime.p7s");
 766     t->encoding = ENCBASE64;
 767     t->use_disp = 1;
 768     t->disposition = DISPATTACH;
 769     t->d_filename = m_strdup("smime.p7s");
 770   }
 771   else {
 772     t->subtype = m_strdup("pgp-signature");
 773     t->use_disp = 0;
 774     t->disposition = DISPINLINE;
 775     t->encoding = ENC7BIT;
 776   }
 777   t->filename = sigfile;
 778   t->unlink = 1;                /* ok to remove this file after sending. */
 779
 780   return a;
 781 }
 782
 783
 784 BODY *pgp_gpgme_sign_message (BODY * a)
 785 {
 786   return sign_message (a, 0);
 787 }
 788
 789 BODY *smime_gpgme_sign_message (BODY * a)
 790 {
 791   return sign_message (a, 1);
 792 }
 793
 794 /*
 795  * Implementation of `encrypt_message'.
 796  */
 797
 798 /* Encrypt the mail body A to all keys given as space separated keyids
 799    or fingerprints in KEYLIST and return the encrypted body.  */
 800 BODY *pgp_gpgme_encrypt_message (BODY * a, char *keylist, int sign)
 801 {
 802   char *outfile = NULL;
 803   BODY *t;
 804   gpgme_key_t *rset = NULL;
 805   gpgme_data_t plaintext;
 806
 807   rset = create_recipient_set (keylist, GPGME_PROTOCOL_OpenPGP);
 808   if (!rset)
 809     return NULL;
 810
 811   if (sign)
 812     convert_to_7bit (a);
 813   plaintext = body_to_data_object (a, 0);
 814   if (!plaintext) {
 815     p_delete(&rset);
 816     return NULL;
 817   }
 818
 819   outfile = encrypt_gpgme_object (plaintext, rset, 0, sign);
 820   gpgme_data_release (plaintext);
 821   p_delete(&rset);
 822   if (!outfile)
 823     return NULL;
 824
 825   t = body_new();
 826   t->type = TYPEMULTIPART;
 827   t->subtype = m_strdup("encrypted");
 828   t->encoding = ENC7BIT;
 829   t->use_disp = 0;
 830   t->disposition = DISPINLINE;
 831
 832   parameter_set_boundary(&t->parameter);
 833   parameter_setval(&t->parameter, "protocol", "application/pgp-encrypted");
 834
 835   t->parts = body_new();
 836   t->parts->type = TYPEAPPLICATION;
 837   t->parts->subtype = m_strdup("pgp-encrypted");
 838   t->parts->encoding = ENC7BIT;
 839
 840   t->parts->next = body_new();
 841   t->parts->next->type = TYPEAPPLICATION;
 842   t->parts->next->subtype = m_strdup("octet-stream");
 843   t->parts->next->encoding = ENC7BIT;
 844   t->parts->next->filename = outfile;
 845   t->parts->next->use_disp = 1;
 846   t->parts->next->disposition = DISPINLINE;
 847   t->parts->next->unlink = 1;   /* delete after sending the message */
 848   t->parts->next->d_filename = m_strdup("msg.asc"); /* non pgp/mime
 849                                                            can save */
 850
 851   return t;
 852 }
 853
 854 /*
 855  * Implementation of `smime_build_smime_entity'.
 856  */
 857
 858 /* Encrypt the mail body A to all keys given as space separated
 859    fingerprints in KEYLIST and return the S/MIME encrypted body.  */
 860 BODY *smime_gpgme_build_smime_entity (BODY * a, char *keylist)
 861 {
 862   char *outfile = NULL;
 863   BODY *t;
 864   gpgme_key_t *rset = NULL;
 865   gpgme_data_t plaintext;
 866
 867   rset = create_recipient_set (keylist, GPGME_PROTOCOL_CMS);
 868   if (!rset)
 869     return NULL;
 870
 871   plaintext = body_to_data_object (a, 0);
 872   if (!plaintext) {
 873     p_delete(&rset);
 874     return NULL;
 875   }
 876
 877   outfile = encrypt_gpgme_object (plaintext, rset, 1, 0);
 878   gpgme_data_release (plaintext);
 879   p_delete(&rset);
 880   if (!outfile)
 881     return NULL;
 882
 883   t = body_new();
 884   t->type = TYPEAPPLICATION;
 885   t->subtype = m_strdup("pkcs7-mime");
 886   parameter_setval(&t->parameter, "name", "smime.p7m");
 887   parameter_setval(&t->parameter, "smime-type", "enveloped-data");
 888   t->encoding = ENCBASE64;      /* The output of OpenSSL SHOULD be binary */
 889   t->use_disp = 1;
 890   t->disposition = DISPATTACH;
 891   t->d_filename = m_strdup("smime.p7m");
 892   t->filename = outfile;
 893   t->unlink = 1;                /*delete after sending the message */
 894   t->parts = 0;
 895   t->next = 0;
 896
 897   return t;
 898 }
 899
 900
 901 /*
 902  * Implementation of `verify_one'.
 903  */
 904
 905 /* Display the common attributes of the signature summary SUM.
 906    Return 1 if there is is a severe warning.
 907  */
 908 static int show_sig_summary (unsigned long sum,
 909                              gpgme_ctx_t ctx, gpgme_key_t key, int idx,
 910                              STATE * s)
 911 {
 912   int severe = 0;
 913
 914   if ((sum & GPGME_SIGSUM_KEY_REVOKED)) {
 915     state_attach_puts (_("Warning: One of the keys has been revoked\n"), s);
 916     severe = 1;
 917   }
 918
 919   if ((sum & GPGME_SIGSUM_KEY_EXPIRED)) {
 920     time_t at = key->subkeys->expires ? key->subkeys->expires : 0;
 921
 922     if (at) {
 923       state_attach_puts (_("Warning: The key used to create the "
 924                            "signature expired at: "), s);
 925       print_time (at, s);
 926       state_attach_puts ("\n", s);
 927     }
 928     else
 929       state_attach_puts (_("Warning: At least one certification key "
 930                            "has expired\n"), s);
 931   }
 932
 933   if ((sum & GPGME_SIGSUM_SIG_EXPIRED)) {
 934     gpgme_verify_result_t result;
 935     gpgme_signature_t sig;
 936     int i;
 937
 938     result = gpgme_op_verify_result (ctx);
 939
 940     for (sig = result->signatures, i = 0; sig && (i < idx);
 941          sig = sig->next, i++);
 942
 943     state_attach_puts (_("Warning: The signature expired at: "), s);
 944     print_time (sig ? sig->exp_timestamp : 0, s);
 945     state_attach_puts ("\n", s);
 946   }
 947
 948   if ((sum & GPGME_SIGSUM_KEY_MISSING))
 949     state_attach_puts (_("Can't verify due to a missing "
 950                          "key or certificate\n"), s);
 951
 952   if ((sum & GPGME_SIGSUM_CRL_MISSING)) {
 953     state_attach_puts (_("The CRL is not available\n"), s);
 954     severe = 1;
 955   }
 956
 957   if ((sum & GPGME_SIGSUM_CRL_TOO_OLD)) {
 958     state_attach_puts (_("Available CRL is too old\n"), s);
 959     severe = 1;
 960   }
 961
 962   if ((sum & GPGME_SIGSUM_BAD_POLICY))
 963     state_attach_puts (_("A policy requirement was not met\n"), s);
 964
 965   if ((sum & GPGME_SIGSUM_SYS_ERROR)) {
 966     const char *t0 = NULL, *t1 = NULL;
 967     gpgme_verify_result_t result;
 968     gpgme_signature_t sig;
 969     int i;
 970
 971     state_attach_puts (_("A system error occurred"), s);
 972
 973     /* Try to figure out some more detailed system error information. */
 974     result = gpgme_op_verify_result (ctx);
 975     for (sig = result->signatures, i = 0; sig && (i < idx);
 976          sig = sig->next, i++);
 977     if (sig) {
 978       t0 = "";
 979       t1 = sig->wrong_key_usage ? "Wrong_Key_Usage" : "";
 980     }
 981
 982     if (t0 || t1) {
 983       state_attach_puts (": ", s);
 984       if (t0)
 985         state_attach_puts (t0, s);
 986       if (t1 && !(t0 && !m_strcmp(t0, t1))) {
 987         if (t0)
 988           state_attach_puts (",", s);
 989         state_attach_puts (t1, s);
 990       }
 991     }
 992     state_attach_puts ("\n", s);
 993   }
 994
 995   return severe;
 996 }
 997
 998
 999 static void show_fingerprint (gpgme_key_t key, STATE * state)
1000 {
1001   const char *s;
1002   int i, is_pgp;
1003   char *buf, *p;
1004   const char *prefix = _("Fingerprint: ");
1005   ssize_t bufsize;
1006
1007   if (!key)
1008     return;
1009   s = key->subkeys ? key->subkeys->fpr : NULL;
1010   if (!s)
1011     return;
1012   is_pgp = (key->protocol == GPGME_PROTOCOL_OpenPGP);
1013
1014   bufsize = m_strlen(prefix) + m_strlen(s) * 4 + 2;
1015   buf = xmalloc(bufsize);
1016   m_strcpy(buf, bufsize, prefix);
1017   p = buf + m_strlen(buf);
1018   if (is_pgp && m_strlen(s) == 40) {     /* PGP v4 style formatted. */
1019     for (i = 0; *s && s[1] && s[2] && s[3] && s[4]; s += 4, i++) {
1020       *p++ = s[0];
1021       *p++ = s[1];
1022       *p++ = s[2];
1023       *p++ = s[3];
1024       *p++ = ' ';
1025       if (i == 4)
1026         *p++ = ' ';
1027     }
1028   }
1029   else {
1030     for (i = 0; *s && s[1] && s[2]; s += 2, i++) {
1031       *p++ = s[0];
1032       *p++ = s[1];
1033       *p++ = is_pgp ? ' ' : ':';
1034       if (is_pgp && i == 7)
1035         *p++ = ' ';
1036     }
1037   }
1038
1039   /* just in case print remaining odd digits */
1040   for (; *s; s++)
1041     *p++ = *s;
1042   *p++ = '\n';
1043   *p = 0;
1044   state_attach_puts (buf, state);
1045   p_delete(&buf);
1046 }
1047
1048 /* Show the valididy of a key used for one signature. */
1049 static void show_one_sig_validity (gpgme_ctx_t ctx, int idx, STATE * s)
1050 {
1051   gpgme_verify_result_t result = NULL;
1052   gpgme_signature_t sig = NULL;
1053   const char *txt = NULL;
1054
1055   result = gpgme_op_verify_result (ctx);
1056   if (result)
1057     for (sig = result->signatures; sig && (idx > 0); sig = sig->next, idx--);
1058
1059   switch (sig ? sig->validity : 0) {
1060   case GPGME_VALIDITY_UNKNOWN:
1061     txt = _("WARNING: We have NO indication whether "
1062             "the key belongs to the person named " "as shown above\n");
1063     break;
1064   case GPGME_VALIDITY_UNDEFINED:
1065     break;
1066   case GPGME_VALIDITY_NEVER:
1067     txt = _("WARNING: The key does NOT BELONG to "
1068             "the person named as shown above\n");
1069     break;
1070   case GPGME_VALIDITY_MARGINAL:
1071     txt = _("WARNING: It is NOT certain that the key "
1072             "belongs to the person named as shown above\n");
1073     break;
1074   case GPGME_VALIDITY_FULL:
1075   case GPGME_VALIDITY_ULTIMATE:
1076     txt = NULL;
1077     break;
1078   }
1079   if (txt)
1080     state_attach_puts (txt, s);
1081 }
1082
1083 /* Show information about one signature.  This fucntion is called with
1084    the context CTX of a sucessful verification operation and the
1085    enumerator IDX which should start at 0 and incremete for each
1086    call/signature.
1087
1088    Return values are: 0 for normal procession, 1 for a bad signature,
1089    2 for a signature with a warning or -1 for no more signature.  */
1090 static int show_one_sig_status (gpgme_ctx_t ctx, int idx, STATE * s)
1091 {
1092   time_t created;
1093   const char *fpr, *uid;
1094   gpgme_key_t key = NULL;
1095   int i, anybad = 0, anywarn = 0;
1096   unsigned int sum;
1097   gpgme_user_id_t uids = NULL;
1098   gpgme_verify_result_t result;
1099   gpgme_signature_t sig;
1100   gpgme_error_t err = GPG_ERR_NO_ERROR;
1101
1102   result = gpgme_op_verify_result (ctx);
1103   if (result) {
1104     /* FIXME: this code should use a static variable and remember
1105        the current position in the list of signatures, IMHO.
1106        -moritz.  */
1107
1108     for (i = 0, sig = result->signatures; sig && (i < idx);
1109          i++, sig = sig->next);
1110     if (!sig)
1111       return -1;                /* Signature not found.  */
1112
1113     if (signature_key) {
1114       gpgme_key_release (signature_key);
1115       signature_key = NULL;
1116     }
1117
1118     created = sig->timestamp;
1119     fpr = sig->fpr;
1120     sum = sig->summary;
1121
1122     if (gpg_err_code (sig->status) != GPG_ERR_NO_ERROR)
1123       anybad = 1;
1124
1125     err = gpgme_get_key (ctx, fpr, &key, 0);    /* secret key?  */
1126     if (!err) {
1127       uid = (key->uids && key->uids->uid) ? key->uids->uid : "[?]";
1128       if (!signature_key)
1129         signature_key = key;
1130     }
1131     else {
1132       key = NULL;               /* Old gpgme versions did not set KEY to NULL on
1133                                    error.   Do it here to avoid a double free. */
1134       uid = "[?]";
1135     }
1136
1137     if (!s || !s->fpout || !(s->flags & M_DISPLAY));    /* No state information so no way to print anything. */
1138     else if (err) {
1139       state_attach_puts (_("Error getting key information: "), s);
1140       state_attach_puts (gpg_strerror (err), s);
1141       state_attach_puts ("\n", s);
1142       anybad = 1;
1143     }
1144     else if ((sum & GPGME_SIGSUM_GREEN)) {
1145       state_attach_puts (_("Good signature from: "), s);
1146       state_attach_puts (uid, s);
1147       state_attach_puts ("\n", s);
1148       for (i = 1, uids = key->uids; uids; i++, uids = uids->next) {
1149         if (i == 1)
1150           /* Skip primary UID.  */
1151           continue;
1152         if (uids->revoked)
1153           continue;
1154         state_attach_puts (_("                aka: "), s);
1155         state_attach_puts (uids->uid, s);
1156         state_attach_puts ("\n", s);
1157       }
1158       state_attach_puts (_("            created: "), s);
1159       print_time (created, s);
1160       state_attach_puts ("\n", s);
1161       if (show_sig_summary (sum, ctx, key, idx, s))
1162         anywarn = 1;
1163       show_one_sig_validity (ctx, idx, s);
1164     }
1165     else if ((sum & GPGME_SIGSUM_RED)) {
1166       state_attach_puts (_("*BAD* signature claimed to be from: "), s);
1167       state_attach_puts (uid, s);
1168       state_attach_puts ("\n", s);
1169       show_sig_summary (sum, ctx, key, idx, s);
1170     }
1171     else if (!anybad && key && (key->protocol == GPGME_PROTOCOL_OpenPGP)) {     /* We can't decide (yellow) but this is a PGP key with a good
1172                                                                                    signature, so we display what a PGP user expects: The name,
1173                                                                                    fingerprint and the key validity (which is neither fully or
1174                                                                                    ultimate). */
1175       state_attach_puts (_("Good signature from: "), s);
1176       state_attach_puts (uid, s);
1177       state_attach_puts ("\n", s);
1178       state_attach_puts (_("            created: "), s);
1179       print_time (created, s);
1180       state_attach_puts ("\n", s);
1181       show_one_sig_validity (ctx, idx, s);
1182       show_fingerprint (key, s);
1183       if (show_sig_summary (sum, ctx, key, idx, s))
1184         anywarn = 1;
1185     }
1186     else {                      /* can't decide (yellow) */
1187
1188       state_attach_puts (_("Error checking signature"), s);
1189       state_attach_puts ("\n", s);
1190       show_sig_summary (sum, ctx, key, idx, s);
1191     }
1192
1193     if (key != signature_key)
1194       gpgme_key_release (key);
1195   }
1196
1197   return anybad ? 1 : anywarn ? 2 : 0;
1198 }
1199
1200 /* Do the actual verification step. With IS_SMIME set to true we
1201    assume S/MIME (surprise!) */
1202 static int verify_one (BODY * sigbdy, STATE * s,
1203                        const char *tempfile, int is_smime)
1204 {
1205   int badsig = -1;
1206   int anywarn = 0;
1207   int err;
1208   gpgme_ctx_t ctx;
1209   gpgme_data_t signature, message;
1210
1211   signature = file_to_data_object (s->fpin, sigbdy->offset, sigbdy->length);
1212   if (!signature)
1213     return -1;
1214
1215   /* We need to tell gpgme about the encoding because the backend can't
1216      auto-detect plain base-64 encoding which is used by S/MIME. */
1217   if (is_smime)
1218     gpgme_data_set_encoding (signature, GPGME_DATA_ENCODING_BASE64);
1219
1220   err = gpgme_data_new_from_file (&message, tempfile, 1);
1221   if (err) {
1222     gpgme_data_release (signature);
1223     mutt_error (_("error allocating data object: %s\n"), gpgme_strerror (err));
1224     return -1;
1225   }
1226   ctx = create_gpgme_context (is_smime);
1227
1228   /* Note: We don't need a current time output because GPGME avoids
1229      such an attack by separating the meta information from the
1230      data. */
1231   state_attach_puts (_("[-- Begin signature information --]\n"), s);
1232
1233   err = gpgme_op_verify (ctx, signature, message, NULL);
1234   mutt_need_hard_redraw ();
1235   if (err) {
1236     char buf[200];
1237
1238     snprintf (buf, sizeof (buf) - 1,
1239               _("Error: verification failed: %s\n"), gpgme_strerror (err));
1240     state_attach_puts (buf, s);
1241   }
1242   else {                        /* Verification succeeded, see what the result is. */
1243     int res, idx;
1244     int anybad = 0;
1245
1246     if (signature_key) {
1247       gpgme_key_release (signature_key);
1248       signature_key = NULL;
1249     }
1250
1251     for (idx = 0; (res = show_one_sig_status (ctx, idx, s)) != -1; idx++) {
1252       if (res == 1)
1253         anybad = 1;
1254       else if (res == 2)
1255         anywarn = 2;
1256     }
1257     if (!anybad)
1258       badsig = 0;
1259   }
1260
1261   if (!badsig) {
1262     gpgme_verify_result_t result;
1263     gpgme_sig_notation_t notation;
1264     gpgme_signature_t sig;
1265
1266     result = gpgme_op_verify_result (ctx);
1267     if (result) {
1268       for (sig = result->signatures; sig; sig = sig->next) {
1269         if (sig->notations) {
1270           state_attach_puts ("*** Begin Notation (signature by: ", s);
1271           state_attach_puts (sig->fpr, s);
1272           state_attach_puts (") ***\n", s);
1273           for (notation = sig->notations; notation; notation = notation->next)
1274           {
1275             if (notation->name) {
1276               state_attach_puts (notation->name, s);
1277               state_attach_puts ("=", s);
1278             }
1279             if (notation->value) {
1280               state_attach_puts (notation->value, s);
1281               if (!(*notation->value
1282                     && (notation->value[m_strlen(notation->value) - 1] ==
1283                         '\n')))
1284                 state_attach_puts ("\n", s);
1285             }
1286           }
1287           state_attach_puts ("*** End Notation ***\n", s);
1288         }
1289       }
1290     }
1291   }
1292
1293   gpgme_release (ctx);
1294
1295   state_attach_puts (_("[-- End signature information --]\n\n"), s);
1296
1297   return badsig ? 1 : anywarn ? 2 : 0;
1298 }
1299
1300 int pgp_gpgme_verify_one (BODY * sigbdy, STATE * s, const char *tempfile)
1301 {
1302   return verify_one (sigbdy, s, tempfile, 0);
1303 }
1304
1305 int smime_gpgme_verify_one (BODY * sigbdy, STATE * s, const char *tempfile)
1306 {
1307   return verify_one (sigbdy, s, tempfile, 1);
1308 }
1309
1310 /*
1311  * Implementation of `decrypt_part'.
1312  */
1313
1314 /* Decrypt a PGP or SMIME message (depending on the boolean flag
1315    IS_SMIME) with body A described further by state S.  Write
1316    plaintext out to file FPOUT and return a new body.  For PGP returns
1317    a flag in R_IS_SIGNED to indicate whether this is a combined
1318    encrypted and signed message, for S/MIME it returns true when it is
1319    not a encrypted but a signed message.  */
1320 static BODY *decrypt_part (BODY * a, STATE * s, FILE * fpout, int is_smime,
1321                            int *r_is_signed)
1322 {
1323   struct stat info;
1324   BODY *tattach;
1325   int err = 0;
1326   gpgme_ctx_t ctx;
1327   gpgme_data_t ciphertext, plaintext;
1328   int maybe_signed = 0;
1329   int anywarn = 0;
1330   int sig_stat = 0;
1331
1332   if (r_is_signed)
1333     *r_is_signed = 0;
1334
1335   ctx = create_gpgme_context (is_smime);
1336
1337 restart:
1338   /* Make a data object from the body, create context etc. */
1339   ciphertext = file_to_data_object (s->fpin, a->offset, a->length);
1340   if (!ciphertext)
1341     return NULL;
1342   plaintext = create_gpgme_data ();
1343
1344   /* Do the decryption or the verification in case of the S/MIME hack. */
1345   if ((!is_smime) || maybe_signed) {
1346     if (!is_smime)
1347       err = gpgme_op_decrypt_verify (ctx, ciphertext, plaintext);
1348     else if (maybe_signed)
1349       err = gpgme_op_verify (ctx, ciphertext, NULL, plaintext);
1350
1351     {
1352       /* Check wether signatures have been verified.  */
1353       gpgme_verify_result_t verify_result = gpgme_op_verify_result (ctx);
1354
1355       if (verify_result->signatures)
1356         sig_stat = 1;
1357     }
1358   }
1359   else
1360     err = gpgme_op_decrypt (ctx, ciphertext, plaintext);
1361   gpgme_data_release (ciphertext);
1362   if (err) {
1363     if (is_smime && !maybe_signed && gpg_err_code (err) == GPG_ERR_NO_DATA) {
1364       /* Check whether this might be a signed message despite what
1365          the mime header told us.  Retry then.  gpgsm returns the
1366          error information "unsupported Algorithm '?'" but gpgme
1367          will not store this unknown algorithm, thus we test that
1368          it has not been set. */
1369       gpgme_decrypt_result_t result;
1370
1371       result = gpgme_op_decrypt_result (ctx);
1372       if (!result->unsupported_algorithm) {
1373         maybe_signed = 1;
1374         gpgme_data_release (plaintext);
1375         goto restart;
1376       }
1377     }
1378     mutt_need_hard_redraw ();
1379     if ((s->flags & M_DISPLAY)) {
1380       char buf[200];
1381
1382       snprintf (buf, sizeof (buf) - 1,
1383                 _("[-- Error: decryption failed: %s --]\n\n"),
1384                 gpgme_strerror (err));
1385       state_attach_puts (buf, s);
1386     }
1387     gpgme_data_release (plaintext);
1388     gpgme_release (ctx);
1389     return NULL;
1390   }
1391   mutt_need_hard_redraw ();
1392
1393   /* Read the output from GPGME, and make sure to change CRLF to LF,
1394      otherwise read_mime_header has a hard time parsing the message.  */
1395   if (data_object_to_stream (plaintext, fpout)) {
1396     gpgme_data_release (plaintext);
1397     gpgme_release (ctx);
1398     return NULL;
1399   }
1400   gpgme_data_release (plaintext);
1401
1402   a->is_signed_data = 0;
1403   if (sig_stat) {
1404     int res, idx;
1405     int anybad = 0;
1406
1407     if (maybe_signed)
1408       a->is_signed_data = 1;
1409     if (r_is_signed)
1410       *r_is_signed = -1;        /* A signature exists. */
1411
1412     if ((s->flags & M_DISPLAY))
1413       state_attach_puts (_("[-- Begin signature " "information --]\n"), s);
1414     for (idx = 0; (res = show_one_sig_status (ctx, idx, s)) != -1; idx++) {
1415       if (res == 1)
1416         anybad = 1;
1417       else if (res == 2)
1418         anywarn = 1;
1419     }
1420     if (!anybad && idx && r_is_signed && *r_is_signed)
1421       *r_is_signed = anywarn ? 2 : 1;   /* Good signature. */
1422
1423     if ((s->flags & M_DISPLAY))
1424       state_attach_puts (_("[-- End signature " "information --]\n\n"), s);
1425   }
1426   gpgme_release (ctx);
1427   ctx = NULL;
1428
1429   fflush (fpout);
1430   rewind (fpout);
1431   tattach = mutt_read_mime_header (fpout, 0);
1432   if (tattach) {
1433     /*
1434      * Need to set the length of this body part.
1435      */
1436     fstat (fileno (fpout), &info);
1437     tattach->length = info.st_size - tattach->offset;
1438
1439     tattach->warnsig = anywarn;
1440
1441     /* See if we need to recurse on this MIME part.  */
1442     mutt_parse_part (fpout, tattach);
1443   }
1444
1445   return tattach;
1446 }
1447
1448 /* Decrypt a PGP/MIME message in FPIN and B and return a new body and
1449    the stream in CUR and FPOUT.  Returns 0 on success. */
1450 int pgp_gpgme_decrypt_mime (FILE * fpin, FILE ** fpout, BODY * b, BODY ** cur)
1451 {
1452   char tempfile[_POSIX_PATH_MAX];
1453   STATE s;
1454   BODY *first_part = b;
1455   int is_signed;
1456
1457   first_part->goodsig = 0;
1458   first_part->warnsig = 0;
1459
1460   if (!mutt_is_multipart_encrypted (b))
1461     return -1;
1462
1463   if (!b->parts || !b->parts->next)
1464     return -1;
1465
1466   b = b->parts->next;
1467
1468   p_clear(&s, 1);
1469   s.fpin = fpin;
1470   *fpout = m_tempfile(tempfile, sizeof(tempfile), NONULL(Tempdir), NULL);
1471   if (!*fpout) {
1472     mutt_perror (_("Can't create temporary file"));
1473     return -1;
1474   }
1475   unlink (tempfile);
1476
1477   *cur = decrypt_part (b, &s, *fpout, 0, &is_signed);
1478   rewind (*fpout);
1479   if (is_signed > 0)
1480     first_part->goodsig = 1;
1481
1482   return *cur ? 0 : -1;
1483 }
1484
1485
1486 /* Decrypt a S/MIME message in FPIN and B and return a new body and
1487    the stream in CUR and FPOUT.  Returns 0 on success. */
1488 int smime_gpgme_decrypt_mime (FILE * fpin, FILE ** fpout, BODY * b,
1489                               BODY ** cur)
1490 {
1491   char tempfile[_POSIX_PATH_MAX];
1492   STATE s;
1493   FILE *tmpfp = NULL;
1494   int is_signed;
1495   long saved_b_offset;
1496   ssize_t saved_b_length;
1497   int saved_b_type;
1498
1499   if (!mutt_is_application_smime (b))
1500     return -1;
1501
1502   if (b->parts)
1503     return -1;
1504
1505   /* Decode the body - we need to pass binary CMS to the
1506      backend.  The backend allows for Base64 encoded data but it does
1507      not allow for QP which I have seen in some messages.  So better
1508      do it here. */
1509   saved_b_type = b->type;
1510   saved_b_offset = b->offset;
1511   saved_b_length = b->length;
1512   p_clear(&s, 1);
1513   s.fpin = fpin;
1514   fseeko (s.fpin, b->offset, 0);
1515   tmpfp = m_tempfile (tempfile, sizeof(tempfile), NONULL(Tempdir), NULL);
1516   if (!tmpfp) {
1517     mutt_perror (_("Can't create temporary file"));
1518     return -1;
1519   }
1520   mutt_unlink (tempfile);
1521
1522   s.fpout = tmpfp;
1523   mutt_decode_attachment (b, &s);
1524   fflush (tmpfp);
1525   b->length = ftello (s.fpout);
1526   b->offset = 0;
1527   rewind (tmpfp);
1528
1529   p_clear(&s, 1);
1530   s.fpin = tmpfp;
1531   s.fpout = 0;
1532   *fpout = m_tempfile(tempfile, sizeof(tempfile), NONULL(Tempdir), NULL);
1533   if (!*fpout) {
1534     mutt_perror (_("Can't create temporary file"));
1535     return -1;
1536   }
1537   mutt_unlink (tempfile);
1538
1539   *cur = decrypt_part (b, &s, *fpout, 1, &is_signed);
1540   if (*cur)
1541     (*cur)->goodsig = is_signed > 0;
1542   b->type = saved_b_type;
1543   b->length = saved_b_length;
1544   b->offset = saved_b_offset;
1545   m_fclose(&tmpfp);
1546   rewind (*fpout);
1547   if (*cur && !is_signed && !(*cur)->parts
1548       && mutt_is_application_smime (*cur)) {
1549     /* Assume that this is a opaque signed s/mime message.  This is
1550        an ugly way of doing it but we have anyway a problem with
1551        arbitrary encoded S/MIME messages: Only the outer part may be
1552        encrypted.  The entire mime parsing should be revamped,
1553        probably by keeping the temportary files so that we don't
1554        need to decrypt them all the time.  Inner parts of an
1555        encrypted part can then pint into this file and tehre won't
1556        never be a need to decrypt again.  This needs a partial
1557        rewrite of the MIME engine. */
1558     BODY *bb = *cur;
1559     BODY *tmp_b;
1560
1561     saved_b_type = bb->type;
1562     saved_b_offset = bb->offset;
1563     saved_b_length = bb->length;
1564     p_clear(&s, 1);
1565     s.fpin = *fpout;
1566     fseeko (s.fpin, bb->offset, 0);
1567     tmpfp = m_tempfile (tempfile, sizeof(tempfile), NONULL(Tempdir), NULL);
1568     if (!tmpfp) {
1569       mutt_perror (_("Can't create temporary file"));
1570       return -1;
1571     }
1572     mutt_unlink (tempfile);
1573
1574     s.fpout = tmpfp;
1575     mutt_decode_attachment (bb, &s);
1576     fflush (tmpfp);
1577     bb->length = ftello (s.fpout);
1578     bb->offset = 0;
1579     rewind (tmpfp);
1580     m_fclose(&*fpout);
1581
1582     p_clear(&s, 1);
1583     s.fpin = tmpfp;
1584     s.fpout = 0;
1585     *fpout = m_tempfile(tempfile, sizeof(tempfile), NONULL(Tempdir), NULL);
1586     if (!*fpout) {
1587       mutt_perror (_("Can't create temporary file"));
1588       return -1;
1589     }
1590     mutt_unlink (tempfile);
1591
1592     tmp_b = decrypt_part (bb, &s, *fpout, 1, &is_signed);
1593     if (tmp_b)
1594       tmp_b->goodsig = is_signed > 0;
1595     bb->type = saved_b_type;
1596     bb->length = saved_b_length;
1597     bb->offset = saved_b_offset;
1598     m_fclose(&tmpfp);
1599     rewind (*fpout);
1600     body_list_wipe(cur);
1601     *cur = tmp_b;
1602   }
1603   return *cur ? 0 : -1;
1604 }
1605
1606
1607 /*
1608  * Implementation of `pgp_check_traditional'.
1609  */
1610
1611 static int pgp_check_traditional_one_body (FILE * fp, BODY * b,
1612                                            int tagged_only)
1613 {
1614   char tempfile[_POSIX_PATH_MAX];
1615   char buf[HUGE_STRING];
1616   FILE *tfp;
1617
1618   short sgn = 0;
1619   short enc = 0;
1620
1621   if (b->type != TYPETEXT)
1622     return 0;
1623
1624   if (tagged_only && !b->tagged)
1625     return 0;
1626
1627   mutt_mktemp (tempfile);
1628   if (mutt_decode_save_attachment (fp, b, tempfile, 0, 0) != 0) {
1629     unlink (tempfile);
1630     return 0;
1631   }
1632
1633   if ((tfp = fopen (tempfile, "r")) == NULL) {
1634     unlink (tempfile);
1635     return 0;
1636   }
1637
1638   while (fgets (buf, sizeof (buf), tfp)) {
1639     if (!m_strncmp("-----BEGIN PGP ", buf, 15)) {
1640       if (!m_strcmp("MESSAGE-----\n", buf + 15))
1641         enc = 1;
1642       else if (!m_strcmp("SIGNED MESSAGE-----\n", buf + 15))
1643         sgn = 1;
1644     }
1645   }
1646   m_fclose(&tfp);
1647   unlink (tempfile);
1648
1649   if (!enc && !sgn)
1650     return 0;
1651
1652   /* fix the content type */
1653
1654   parameter_setval(&b->parameter, "format", "fixed");
1655   parameter_setval(&b->parameter, "x-action",
1656                    enc ? "pgp-encrypted" : "pgp-signed");
1657   return 1;
1658 }
1659
1660 int pgp_gpgme_check_traditional (FILE * fp, BODY * b, int tagged_only)
1661 {
1662   int rv = 0;
1663   int r;
1664
1665   for (; b; b = b->next) {
1666     if (is_multipart (b))
1667       rv = (pgp_gpgme_check_traditional (fp, b->parts, tagged_only) || rv);
1668     else if (b->type == TYPETEXT) {
1669       if ((r = mutt_is_application_pgp (b)))
1670         rv = (rv || r);
1671       else
1672         rv = (pgp_check_traditional_one_body (fp, b, tagged_only) || rv);
1673     }
1674   }
1675   return rv;
1676 }
1677
1678
1679 /*
1680  * Implementation of `application_handler'.
1681  */
1682
1683 /*
1684   Copy a clearsigned message, and strip the signature and PGP's
1685   dash-escaping.
1686
1687   XXX - charset handling: We assume that it is safe to do
1688   character set decoding first, dash decoding second here, while
1689   we do it the other way around in the main handler.
1690
1691   (Note that we aren't worse than Outlook & Cie in this, and also
1692   note that we can successfully handle anything produced by any
1693   existing versions of mutt.)  */
1694
1695 static void copy_clearsigned (gpgme_data_t data, STATE * s, char *charset)
1696 {
1697   char buf[HUGE_STRING];
1698   short complete, armor_header;
1699   fgetconv_t *fc;
1700   char *fname;
1701   FILE *fp;
1702
1703   fname = data_object_to_tempfile (data, &fp);
1704   if (!fname)
1705     return;
1706   unlink (fname);
1707   p_delete(&fname);
1708
1709   fc = fgetconv_open (fp, charset, Charset, M_ICONV_HOOK_FROM);
1710
1711   for (complete = 1, armor_header = 1;
1712        fgetconvs (buf, sizeof (buf), fc) != NULL;
1713        complete = strchr (buf, '\n') != NULL) {
1714     if (!complete) {
1715       if (!armor_header)
1716         state_puts (buf, s);
1717       continue;
1718     }
1719
1720     if (!m_strcmp(buf, "-----BEGIN PGP SIGNATURE-----\n"))
1721       break;
1722
1723     if (armor_header) {
1724       if (buf[0] == '\n')
1725         armor_header = 0;
1726       continue;
1727     }
1728
1729     if (s->prefix)
1730       state_puts (s->prefix, s);
1731
1732     if (buf[0] == '-' && buf[1] == ' ')
1733       state_puts (buf + 2, s);
1734     else
1735       state_puts (buf, s);
1736   }
1737
1738   fgetconv_close (&fc);
1739   m_fclose(&fp);
1740 }
1741
1742
1743 /* Support for classic_application/pgp */
1744 int pgp_gpgme_application_handler (BODY * m, STATE * s)
1745 {
1746   int needpass = -1, pgp_keyblock = 0;
1747   int clearsign = 0;
1748   long start_pos = 0;
1749   long bytes;
1750   off_t last_pos, offset;
1751   char buf[HUGE_STRING];
1752   FILE *pgpout = NULL;
1753
1754   gpgme_error_t err = 0;
1755   gpgme_data_t armored_data = NULL;
1756
1757   short maybe_goodsig = 1;
1758   short have_any_sigs = 0;
1759
1760   char body_charset[STRING];    /* Only used for clearsigned messages. */
1761
1762   /* For clearsigned messages we won't be able to get a character set
1763      but we know that this may only be text thus we assume Latin-1
1764      here. */
1765   if (!mutt_get_body_charset (body_charset, sizeof (body_charset), m))
1766     m_strcpy(body_charset, sizeof(body_charset), "iso-8859-1");
1767
1768   fseeko (s->fpin, m->offset, 0);
1769   last_pos = m->offset;
1770
1771   for (bytes = m->length; bytes > 0;) {
1772     if (fgets (buf, sizeof (buf), s->fpin) == NULL)
1773       break;
1774
1775     offset = ftello (s->fpin);
1776     bytes -= (offset - last_pos);       /* don't rely on m_strlen(buf) */
1777     last_pos = offset;
1778
1779     if (!m_strncmp("-----BEGIN PGP ", buf, 15)) {
1780       clearsign = 0;
1781       start_pos = last_pos;
1782
1783       if (!m_strcmp("MESSAGE-----\n", buf + 15))
1784         needpass = 1;
1785       else if (!m_strcmp("SIGNED MESSAGE-----\n", buf + 15)) {
1786         clearsign = 1;
1787         needpass = 0;
1788       }
1789       else if (!option (OPTDONTHANDLEPGPKEYS) &&
1790                !m_strcmp("PUBLIC KEY BLOCK-----\n", buf + 15)) {
1791         needpass = 0;
1792         pgp_keyblock = 1;
1793       }
1794       else {
1795         /* XXX - we may wish to recode here */
1796         if (s->prefix)
1797           state_puts (s->prefix, s);
1798         state_puts (buf, s);
1799         continue;
1800       }
1801
1802       have_any_sigs = (have_any_sigs || (clearsign && (s->flags & M_VERIFY)));
1803
1804       /* Copy PGP material to an data container */
1805       armored_data = create_gpgme_data ();
1806       gpgme_data_write (armored_data, buf, m_strlen(buf));
1807       while (bytes > 0 && fgets (buf, sizeof (buf) - 1, s->fpin) != NULL) {
1808         offset = ftello (s->fpin);
1809         bytes -= (offset - last_pos);   /* don't rely on m_strlen(buf) */
1810         last_pos = offset;
1811
1812         gpgme_data_write (armored_data, buf, m_strlen(buf));
1813
1814         if ((needpass && !m_strcmp("-----END PGP MESSAGE-----\n", buf))
1815             || (!needpass
1816                 && (!m_strcmp("-----END PGP SIGNATURE-----\n", buf)
1817                     || !m_strcmp("-----END PGP PUBLIC KEY BLOCK-----\n",
1818                                      buf))))
1819           break;
1820       }
1821
1822       /* Invoke PGP if needed */
1823       if (!clearsign || (s->flags & M_VERIFY)) {
1824         unsigned int sig_stat = 0;
1825         gpgme_data_t plaintext;
1826         gpgme_ctx_t ctx;
1827
1828         plaintext = create_gpgme_data ();
1829         ctx = create_gpgme_context (0);
1830
1831         if (clearsign)
1832           err = gpgme_op_verify (ctx, armored_data, NULL, plaintext);
1833         else {
1834           err = gpgme_op_decrypt_verify (ctx, armored_data, plaintext);
1835           if (gpg_err_code (err) == GPG_ERR_NO_DATA) {
1836             /* Decrypt verify can't handle signed only messages. */
1837             err = (gpgme_data_seek (armored_data, 0, SEEK_SET) == -1)
1838               ? gpgme_error_from_errno (errno) : 0;
1839             /* Must release plaintext so that we supply an
1840                uninitialized object. */
1841             gpgme_data_release (plaintext);
1842             plaintext = create_gpgme_data ();
1843             err = gpgme_op_verify (ctx, armored_data, NULL, plaintext);
1844           }
1845         }
1846
1847         if (err) {
1848           char errbuf[200];
1849
1850           snprintf (errbuf, sizeof (errbuf) - 1,
1851                     _("Error: decryption/verification failed: %s\n"),
1852                     gpgme_strerror (err));
1853           state_attach_puts (errbuf, s);
1854         }
1855         else {                  /* Decryption/Verification succeeded */
1856           char *tmpfname;
1857
1858           {
1859             /* Check wether signatures have been verified.  */
1860             gpgme_verify_result_t verify_result;
1861
1862             verify_result = gpgme_op_verify_result (ctx);
1863             if (verify_result->signatures)
1864               sig_stat = 1;
1865           }
1866
1867           have_any_sigs = 0;
1868           maybe_goodsig = 0;
1869           if ((s->flags & M_DISPLAY) && sig_stat) {
1870             int res, idx;
1871             int anybad = 0;
1872             int anywarn = 0;
1873
1874             state_attach_puts (_("[-- Begin signature "
1875                                  "information --]\n"), s);
1876             have_any_sigs = 1;
1877             for (idx = 0;
1878                  (res = show_one_sig_status (ctx, idx, s)) != -1; idx++) {
1879               if (res == 1)
1880                 anybad = 1;
1881               else if (res == 2)
1882                 anywarn = 1;
1883             }
1884             if (!anybad && idx)
1885               maybe_goodsig = 1;
1886
1887             state_attach_puts (_("[-- End signature "
1888                                  "information --]\n\n"), s);
1889           }
1890
1891           tmpfname = data_object_to_tempfile (plaintext, &pgpout);
1892           if (!tmpfname) {
1893             pgpout = NULL;
1894             state_attach_puts (_("Error: copy data failed\n"), s);
1895           }
1896           else {
1897             unlink (tmpfname);
1898             p_delete(&tmpfname);
1899           }
1900         }
1901         gpgme_release (ctx);
1902       }
1903
1904       /*
1905        * Now, copy cleartext to the screen.  NOTE - we expect that PGP
1906        * outputs utf-8 cleartext.  This may not always be true, but it
1907        * seems to be a reasonable guess.
1908        */
1909
1910       if (s->flags & M_DISPLAY) {
1911         if (needpass)
1912           state_attach_puts (_("[-- BEGIN PGP MESSAGE --]\n\n"), s);
1913         else if (pgp_keyblock)
1914           state_attach_puts (_("[-- BEGIN PGP PUBLIC KEY BLOCK --]\n"), s);
1915         else
1916           state_attach_puts (_("[-- BEGIN PGP SIGNED MESSAGE --]\n\n"), s);
1917       }
1918
1919       if (clearsign) {
1920         copy_clearsigned (armored_data, s, body_charset);
1921       }
1922       else if (pgpout) {
1923         fgetconv_t *fc;
1924         int c;
1925
1926         rewind (pgpout);
1927         fc = fgetconv_open (pgpout, "utf-8", Charset, 0);
1928         while ((c = fgetconv (fc)) != EOF) {
1929           state_putc (c, s);
1930           if (c == '\n' && s->prefix)
1931             state_puts (s->prefix, s);
1932         }
1933         fgetconv_close (&fc);
1934       }
1935
1936       if (s->flags & M_DISPLAY) {
1937         state_putc ('\n', s);
1938         if (needpass)
1939           state_attach_puts (_("[-- END PGP MESSAGE --]\n"), s);
1940         else if (pgp_keyblock)
1941           state_attach_puts (_("[-- END PGP PUBLIC KEY BLOCK --]\n"), s);
1942         else
1943           state_attach_puts (_("[-- END PGP SIGNED MESSAGE --]\n"), s);
1944       }
1945
1946       if (pgpout) {
1947         m_fclose(&pgpout);
1948       }
1949     }
1950     else {
1951       /* XXX - we may wish to recode here */
1952       if (s->prefix)
1953         state_puts (s->prefix, s);
1954       state_puts (buf, s);
1955     }
1956   }
1957
1958   m->goodsig = (maybe_goodsig && have_any_sigs);
1959
1960   if (needpass == -1) {
1961     state_attach_puts (_("[-- Error: could not find beginning"
1962                          " of PGP message! --]\n\n"), s);
1963     return (-1);
1964   }
1965   return (err);
1966 }
1967
1968 /*
1969  * Implementation of `encrypted_handler'.
1970  */
1971
1972 /* MIME handler for pgp/mime encrypted messages. */
1973 int pgp_gpgme_encrypted_handler (BODY * a, STATE * s)
1974 {
1975   char tempfile[_POSIX_PATH_MAX];
1976   FILE *fpout;
1977   BODY *tattach;
1978   BODY *orig_body = a;
1979   int is_signed;
1980   int rc = 0;
1981
1982   a = a->parts;
1983   if (!a || a->type != TYPEAPPLICATION || !a->subtype
1984       || ascii_strcasecmp ("pgp-encrypted", a->subtype)
1985       || !a->next || a->next->type != TYPEAPPLICATION || !a->next->subtype
1986       || ascii_strcasecmp ("octet-stream", a->next->subtype)) {
1987     if (s->flags & M_DISPLAY)
1988       state_attach_puts (_("[-- Error: malformed PGP/MIME message! --]\n\n"),
1989                          s);
1990     return (-1);
1991   }
1992
1993   /* Move forward to the application/pgp-encrypted body. */
1994   a = a->next;
1995
1996   fpout = m_tempfile(tempfile, sizeof(tempfile), NONULL(Tempdir), NULL);
1997   if (!fpout) {
1998     if (s->flags & M_DISPLAY)
1999       state_attach_puts (_("[-- Error: could not create temporary file! "
2000                            "--]\n"), s);
2001     return (-1);
2002   }
2003
2004   tattach = decrypt_part (a, s, fpout, 0, &is_signed);
2005   if (tattach) {
2006     tattach->goodsig = is_signed > 0;
2007
2008     if (s->flags & M_DISPLAY)
2009       state_attach_puts (is_signed ?
2010                          _
2011                          ("[-- The following data is PGP/MIME signed and encrypted --]\n\n") :
2012                          _("[-- The following data is PGP/MIME encrypted --]\n\n"), s);
2013
2014     {
2015       FILE *savefp = s->fpin;
2016
2017       s->fpin = fpout;
2018       rc = mutt_body_handler (tattach, s);
2019       s->fpin = savefp;
2020     }
2021
2022     /*
2023      * if a multipart/signed is the _only_ sub-part of a
2024      * multipart/encrypted, cache signature verification
2025      * status.
2026      */
2027     if (mutt_is_multipart_signed (tattach) && !tattach->next)
2028       orig_body->goodsig |= tattach->goodsig;
2029
2030     if (s->flags & M_DISPLAY) {
2031       state_puts ("\n", s);
2032       state_attach_puts (is_signed ?
2033                          _
2034                          ("[-- End of PGP/MIME signed and encrypted data --]\n")
2035                          : _("[-- End of PGP/MIME encrypted data --]\n"), s);
2036     }
2037
2038     body_list_wipe(&tattach);
2039   }
2040
2041   m_fclose(&fpout);
2042   mutt_unlink (tempfile);
2043   return (rc);
2044 }
2045
2046 /* Support for application/smime */
2047 int smime_gpgme_application_handler (BODY * a, STATE * s)
2048 {
2049   char tempfile[_POSIX_PATH_MAX];
2050   FILE *fpout;
2051   BODY *tattach;
2052   int is_signed;
2053   int rc = 0;
2054
2055   a->warnsig = 0;
2056   fpout = m_tempfile(tempfile, sizeof(tempfile), NONULL(Tempdir), NULL);
2057   if (!fpout) {
2058     if (s->flags & M_DISPLAY)
2059       state_attach_puts (_("[-- Error: could not create temporary file! "
2060                            "--]\n"), s);
2061     return (-1);
2062   }
2063
2064   tattach = decrypt_part (a, s, fpout, 1, &is_signed);
2065   if (tattach) {
2066     tattach->goodsig = is_signed > 0;
2067
2068     if (s->flags & M_DISPLAY)
2069       state_attach_puts (is_signed ?
2070                          _("[-- The following data is S/MIME signed --]\n\n") :
2071                          _("[-- The following data is S/MIME encrypted --]\n\n"), s);
2072
2073     {
2074       FILE *savefp = s->fpin;
2075
2076       s->fpin = fpout;
2077       rc = mutt_body_handler (tattach, s);
2078       s->fpin = savefp;
2079     }
2080
2081     /*
2082      * if a multipart/signed is the _only_ sub-part of a
2083      * multipart/encrypted, cache signature verification
2084      * status.
2085      */
2086     if (mutt_is_multipart_signed (tattach) && !tattach->next) {
2087       if (!(a->goodsig = tattach->goodsig))
2088         a->warnsig = tattach->warnsig;
2089     }
2090     else if (tattach->goodsig) {
2091       a->goodsig = 1;
2092       a->warnsig = tattach->warnsig;
2093     }
2094
2095     if (s->flags & M_DISPLAY) {
2096       state_puts ("\n", s);
2097       state_attach_puts (is_signed ?
2098                          _("[-- End of S/MIME signed data --]\n") :
2099                          _("[-- End of S/MIME encrypted data --]\n"), s);
2100     }
2101
2102     body_list_wipe(&tattach);
2103   }
2104
2105   m_fclose(&fpout);
2106   mutt_unlink (tempfile);
2107   return (rc);
2108 }
2109
2110
2111 /*
2112  * Format an entry on the CRYPT key selection menu.
2113  *
2114  * %n   number
2115  * %k   key id          %K      key id of the principal key
2116  * %u   user id
2117  * %a   algorithm       %A      algorithm of the princ. key
2118  * %l   length          %L      length of the princ. key
2119  * %f   flags           %F      flags of the princ. key
2120  * %c   capabilities    %C      capabilities of the princ. key
2121  * %t   trust/validity of the key-uid association
2122  * %p           protocol
2123  * %[...] date of key using strftime(3)
2124  */
2125
2126 static const char *
2127 crypt_entry_fmt (char *dest, ssize_t destlen, char op,
2128                  const char *src, const char *prefix,
2129                  const char *ifstr, const char *elstr,
2130                  anytype data, format_flag flags)
2131 {
2132   char fmt[16];
2133   crypt_entry_t *entry;
2134   crypt_key_t *key;
2135   int kflags = 0;
2136   int optional = (flags & M_FORMAT_OPTIONAL);
2137   const char *s = NULL;
2138   unsigned long val;
2139
2140   entry = data.ptr;
2141   key = entry->key;
2142
2143 /*    if (isupper ((unsigned char) op)) */
2144 /*      key = pkey; */
2145
2146   kflags = (key->flags          /*| (pkey->flags & KEYFLAG_RESTRICTIONS)
2147                                    | uid->flags */ );
2148
2149   switch (ascii_tolower (op)) {
2150   case '[':
2151     {
2152       const char *cp;
2153       char buf2[STRING], *p;
2154       int do_locales;
2155       struct tm *tm;
2156       ssize_t len;
2157
2158       p = dest;
2159
2160       cp = src;
2161       if (*cp == '!') {
2162         do_locales = 0;
2163         cp++;
2164       }
2165       else
2166         do_locales = 1;
2167
2168       len = destlen - 1;
2169       while (len > 0 && *cp != ']') {
2170         if (*cp == '%') {
2171           cp++;
2172           if (len >= 2) {
2173             *p++ = '%';
2174             *p++ = *cp;
2175             len -= 2;
2176           }
2177           else
2178             break;              /* not enough space */
2179           cp++;
2180         }
2181         else {
2182           *p++ = *cp++;
2183           len--;
2184         }
2185       }
2186       *p = 0;
2187
2188       if (do_locales && Locale)
2189         setlocale (LC_TIME, Locale);
2190
2191       {
2192         time_t tt = 0;
2193
2194         if (key->kobj->subkeys && (key->kobj->subkeys->timestamp > 0))
2195           tt = key->kobj->subkeys->timestamp;
2196
2197         tm = localtime (&tt);
2198       }
2199       strftime (buf2, sizeof (buf2), dest, tm);
2200
2201       if (do_locales)
2202         setlocale (LC_TIME, "C");
2203
2204       snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
2205       snprintf (dest, destlen, fmt, buf2);
2206       if (len > 0)
2207         src = cp + 1;
2208     }
2209     break;
2210   case 'n':
2211     if (!optional) {
2212       snprintf (fmt, sizeof (fmt), "%%%sd", prefix);
2213       snprintf (dest, destlen, fmt, entry->num);
2214     }
2215     break;
2216   case 'k':
2217     if (!optional) {
2218       /* fixme: we need a way to distinguish between main and subkeys.
2219          Store the idx in entry? */
2220       snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
2221       snprintf (dest, destlen, fmt, crypt_keyid (key));
2222     }
2223     break;
2224   case 'u':
2225     if (!optional) {
2226       snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
2227       snprintf (dest, destlen, fmt, key->uid);
2228     }
2229     break;
2230   case 'a':
2231     if (!optional) {
2232       snprintf (fmt, sizeof (fmt), "%%%s.3s", prefix);
2233       if (key->kobj->subkeys)
2234         s = gpgme_pubkey_algo_name (key->kobj->subkeys->pubkey_algo);
2235       else
2236         s = "?";
2237       snprintf (dest, destlen, fmt, s);
2238     }
2239     break;
2240   case 'l':
2241     if (!optional) {
2242       snprintf (fmt, sizeof (fmt), "%%%slu", prefix);
2243       if (key->kobj->subkeys)
2244         val = key->kobj->subkeys->length;
2245       else
2246         val = 0;
2247       snprintf (dest, destlen, fmt, val);
2248     }
2249     break;
2250   case 'f':
2251     if (!optional) {
2252       snprintf (fmt, sizeof (fmt), "%%%sc", prefix);
2253       snprintf (dest, destlen, fmt, crypt_flags (kflags));
2254     }
2255     else if (!(kflags & (KEYFLAG_RESTRICTIONS)))
2256       optional = 0;
2257     break;
2258   case 'c':
2259     if (!optional) {
2260       snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
2261       snprintf (dest, destlen, fmt, crypt_key_abilities (kflags));
2262     }
2263     else if (!(kflags & (KEYFLAG_ABILITIES)))
2264       optional = 0;
2265     break;
2266   case 't':
2267     if ((kflags & KEYFLAG_ISX509))
2268       s = "x";
2269     else {
2270       gpgme_user_id_t uid = NULL;
2271       int i = 0;
2272
2273       for (i = 0, uid = key->kobj->uids; uid && (i < key->idx);
2274            i++, uid = uid->next);
2275       if (uid)
2276         switch (uid->validity) {
2277         case GPGME_VALIDITY_UNDEFINED:
2278           s = "q";
2279           break;
2280         case GPGME_VALIDITY_NEVER:
2281           s = "n";
2282           break;
2283         case GPGME_VALIDITY_MARGINAL:
2284           s = "m";
2285           break;
2286         case GPGME_VALIDITY_FULL:
2287           s = "f";
2288           break;
2289         case GPGME_VALIDITY_ULTIMATE:
2290           s = "u";
2291           break;
2292         case GPGME_VALIDITY_UNKNOWN:
2293         default:
2294           s = "?";
2295           break;
2296         }
2297     }
2298     snprintf (fmt, sizeof (fmt), "%%%sc", prefix);
2299     snprintf (dest, destlen, fmt, s ? *s : 'B');
2300     break;
2301   case 'p':
2302     snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
2303     snprintf (dest, destlen, fmt,
2304               gpgme_get_protocol_name (key->kobj->protocol));
2305     break;
2306
2307   default:
2308     *dest = '\0';
2309   }
2310
2311   if (flags & M_FORMAT_OPTIONAL)
2312     m_strformat(dest, destlen, optional ? ifstr: elstr,
2313                 mutt_attach_fmt, data, 0);
2314   return src;
2315 }
2316
2317 /* Used by the display fucntion to format a line. */
2318 static void crypt_entry (char *s, ssize_t l, MUTTMENU * menu, int num)
2319 {
2320   crypt_key_t **key_table = (crypt_key_t **) menu->data;
2321   crypt_entry_t entry;
2322
2323   entry.key = key_table[num];
2324   entry.num = num + 1;
2325
2326   m_strformat(s, l, PgpEntryFormat, crypt_entry_fmt, &entry,
2327               option(OPTARROWCURSOR) ? M_FORMAT_ARROWCURSOR : 0);
2328 }
2329
2330 /* Compare two addresses and the keyid to be used for sorting. */
2331 static int _crypt_compare_address (const void *a, const void *b)
2332 {
2333   crypt_key_t **s = (crypt_key_t **) a;
2334   crypt_key_t **t = (crypt_key_t **) b;
2335   int r;
2336
2337   if ((r = m_strcasecmp((*s)->uid, (*t)->uid)))
2338     return r > 0;
2339   else
2340     return m_strcasecmp(crypt_keyid (*s), crypt_keyid (*t)) > 0;
2341 }
2342
2343 static int crypt_compare_address (const void *a, const void *b)
2344 {
2345   return ((PgpSortKeys & SORT_REVERSE) ? !_crypt_compare_address (a, b)
2346           : _crypt_compare_address (a, b));
2347 }
2348
2349
2350 /* Compare two key IDs and the addresses to be used for sorting. */
2351 static int _crypt_compare_keyid (const void *a, const void *b)
2352 {
2353   crypt_key_t **s = (crypt_key_t **) a;
2354   crypt_key_t **t = (crypt_key_t **) b;
2355   int r;
2356
2357   if ((r = m_strcasecmp(crypt_keyid (*s), crypt_keyid (*t))))
2358     return r > 0;
2359   else
2360     return m_strcasecmp((*s)->uid, (*t)->uid) > 0;
2361 }
2362
2363 static int crypt_compare_keyid (const void *a, const void *b)
2364 {
2365   return ((PgpSortKeys & SORT_REVERSE) ? !_crypt_compare_keyid (a, b)
2366           : _crypt_compare_keyid (a, b));
2367 }
2368
2369 /* Compare 2 creation dates and the addresses.  For sorting. */
2370 static int _crypt_compare_date (const void *a, const void *b)
2371 {
2372   crypt_key_t **s = (crypt_key_t **) a;
2373   crypt_key_t **t = (crypt_key_t **) b;
2374   unsigned long ts = 0, tt = 0;
2375
2376   if ((*s)->kobj->subkeys && ((*s)->kobj->subkeys->timestamp > 0))
2377     ts = (*s)->kobj->subkeys->timestamp;
2378   if ((*t)->kobj->subkeys && ((*t)->kobj->subkeys->timestamp > 0))
2379     tt = (*t)->kobj->subkeys->timestamp;
2380
2381   if (ts > tt)
2382     return 1;
2383   if (ts < tt)
2384     return 0;
2385
2386   return m_strcasecmp((*s)->uid, (*t)->uid) > 0;
2387 }
2388
2389 static int crypt_compare_date (const void *a, const void *b)
2390 {
2391   return ((PgpSortKeys & SORT_REVERSE) ? !_crypt_compare_date (a, b)
2392           : _crypt_compare_date (a, b));
2393 }
2394
2395 /* Compare two trust values, the key length, the creation dates. the
2396    addresses and the key IDs.  For sorting. */
2397 static int _crypt_compare_trust (const void *a, const void *b)
2398 {
2399   crypt_key_t **s = (crypt_key_t **) a;
2400   crypt_key_t **t = (crypt_key_t **) b;
2401   unsigned long ts = 0, tt = 0;
2402   int r;
2403
2404   if ((r = (((*s)->flags & (KEYFLAG_RESTRICTIONS))
2405             - ((*t)->flags & (KEYFLAG_RESTRICTIONS)))))
2406     return r > 0;
2407
2408   if ((*s)->kobj->uids)
2409     ts = (*s)->kobj->uids->validity;
2410   if ((*t)->kobj->uids)
2411     tt = (*t)->kobj->uids->validity;
2412   if ((r = (tt - ts)))
2413     return r < 0;
2414
2415   if ((*s)->kobj->subkeys)
2416     ts = (*s)->kobj->subkeys->length;
2417   if ((*t)->kobj->subkeys)
2418     tt = (*t)->kobj->subkeys->length;
2419   if (ts != tt)
2420     return ts > tt;
2421
2422   if ((*s)->kobj->subkeys && ((*s)->kobj->subkeys->timestamp > 0))
2423     ts = (*s)->kobj->subkeys->timestamp;
2424   if ((*t)->kobj->subkeys && ((*t)->kobj->subkeys->timestamp > 0))
2425     tt = (*t)->kobj->subkeys->timestamp;
2426   if (ts > tt)
2427     return 1;
2428   if (ts < tt)
2429     return 0;
2430
2431   if ((r = m_strcasecmp((*s)->uid, (*t)->uid)))
2432     return r > 0;
2433   return (m_strcasecmp(crypt_keyid ((*s)), crypt_keyid ((*t)))) > 0;
2434 }
2435
2436 static int crypt_compare_trust (const void *a, const void *b)
2437 {
2438   return ((PgpSortKeys & SORT_REVERSE) ? !_crypt_compare_trust (a, b)
2439           : _crypt_compare_trust (a, b));
2440 }
2441
2442 /* Print the X.500 Distinguished Name part KEY from the array of parts
2443    DN to FP. */
2444 static int print_dn_part (FILE * fp, struct dn_array_s *dn, const char *key)
2445 {
2446   int any = 0;
2447
2448   for (; dn->key; dn++) {
2449     if (!m_strcmp(dn->key, key)) {
2450       if (any)
2451         fputs (" + ", fp);
2452       print_utf8 (fp, dn->value, m_strlen(dn->value));
2453       any = 1;
2454     }
2455   }
2456   return any;
2457 }
2458
2459 /* Print all parts of a DN in a standard sequence. */
2460 static void print_dn_parts (FILE * fp, struct dn_array_s *dn)
2461 {
2462   const char *stdpart[] = {
2463     "CN", "OU", "O", "STREET", "L", "ST", "C", NULL
2464   };
2465   int any = 0, any2 = 0, i;
2466
2467   for (i = 0; stdpart[i]; i++) {
2468     if (any)
2469       fputs (", ", fp);
2470     any = print_dn_part (fp, dn, stdpart[i]);
2471   }
2472   /* now print the rest without any specific ordering */
2473   for (; dn->key; dn++) {
2474     for (i = 0; stdpart[i]; i++) {
2475       if (!m_strcmp(dn->key, stdpart[i]))
2476         break;
2477     }
2478     if (!stdpart[i]) {
2479       if (any)
2480         fputs (", ", fp);
2481       if (!any2)
2482         fputs ("(", fp);
2483       any = print_dn_part (fp, dn, dn->key);
2484       any2 = 1;
2485     }
2486   }
2487   if (any2)
2488     fputs (")", fp);
2489 }
2490
2491
2492 /* Parse an RDN; this is a helper to parse_dn(). */
2493 static const unsigned char *parse_dn_part (struct dn_array_s *array,
2494                                            const unsigned char *string)
2495 {
2496   const unsigned char *s, *s1;
2497   ssize_t n;
2498   unsigned char *p;
2499
2500   /* parse attributeType */
2501   for (s = string + 1; *s && *s != '='; s++);
2502   if (!*s)
2503     return NULL;                /* error */
2504   n = s - string;
2505   if (!n)
2506     return NULL;                /* empty key */
2507   array->key = p_dupstr(string, n );
2508   p = (unsigned char *) array->key;
2509   string = s + 1;
2510
2511   if (*string == '#') {         /* hexstring */
2512     string++;
2513     for (s = string; hexdigitp (s); s++)
2514       s++;
2515     n = s - string;
2516     if (!n || (n & 1))
2517       return NULL;              /* empty or odd number of digits */
2518     n /= 2;
2519     p = xmalloc(n + 1);
2520     array->value = (char *) p;
2521     for (s1 = string; n; s1 += 2, n--)
2522       *p++ = xtoi_2 (s1);
2523     *p = 0;
2524   }
2525   else {                        /* regular v3 quoted string */
2526     for (n = 0, s = string; *s; s++) {
2527       if (*s == '\\') {         /* pair */
2528         s++;
2529         if (*s == ',' || *s == '=' || *s == '+'
2530             || *s == '<' || *s == '>' || *s == '#' || *s == ';'
2531             || *s == '\\' || *s == '\"' || *s == ' ')
2532           n++;
2533         else if (hexdigitp (s) && hexdigitp (s + 1)) {
2534           s++;
2535           n++;
2536         }
2537         else
2538           return NULL;          /* invalid escape sequence */
2539       }
2540       else if (*s == '\"')
2541         return NULL;            /* invalid encoding */
2542       else if (*s == ',' || *s == '=' || *s == '+'
2543                || *s == '<' || *s == '>' || *s == '#' || *s == ';')
2544         break;
2545       else
2546         n++;
2547     }
2548
2549     p = xmalloc(n + 1);
2550     array->value = (char *) p;
2551     for (s = string; n; s++, n--) {
2552       if (*s == '\\') {
2553         s++;
2554         if (hexdigitp (s)) {
2555           *p++ = xtoi_2 (s);
2556           s++;
2557         }
2558         else
2559           *p++ = *s;
2560       }
2561       else
2562         *p++ = *s;
2563     }
2564     *p = 0;
2565   }
2566   return s;
2567 }
2568
2569
2570 /* Parse a DN and return an array-ized one.  This is not a validating
2571    parser and it does not support any old-stylish syntax; gpgme is
2572    expected to return only rfc2253 compatible strings. */
2573 static struct dn_array_s *parse_dn (const unsigned char *string)
2574 {
2575   struct dn_array_s *array;
2576   ssize_t arrayidx, arraysize;
2577   int i;
2578
2579   arraysize = 7;                /* C,ST,L,O,OU,CN,email */
2580   array = p_new(struct dn_array_s, arraysize + 1);
2581   arrayidx = 0;
2582   while (*string) {
2583     while (*string == ' ')
2584       string++;
2585     if (!*string)
2586       break;                    /* ready */
2587     if (arrayidx >= arraysize) {        /* mutt lacks a real safe_realoc - so we need to copy */
2588       struct dn_array_s *a2;
2589
2590       arraysize += 5;
2591       a2 = p_new(struct dn_array_s, arraysize + 1);
2592       for (i = 0; i < arrayidx; i++) {
2593         a2[i].key = array[i].key;
2594         a2[i].value = array[i].value;
2595       }
2596       p_delete(&array);
2597       array = a2;
2598     }
2599     array[arrayidx].key = NULL;
2600     array[arrayidx].value = NULL;
2601     string = parse_dn_part (array + arrayidx, string);
2602     arrayidx++;
2603     if (!string)
2604       goto failure;
2605     while (*string == ' ')
2606       string++;
2607     if (*string && *string != ',' && *string != ';' && *string != '+')
2608       goto failure;             /* invalid delimiter */
2609     if (*string)
2610       string++;
2611   }
2612   array[arrayidx].key = NULL;
2613   array[arrayidx].value = NULL;
2614   return array;
2615
2616 failure:
2617   for (i = 0; i < arrayidx; i++) {
2618     p_delete(&array[i].key);
2619     p_delete(&array[i].value);
2620   }
2621   p_delete(&array);
2622   return NULL;
2623 }
2624
2625
2626 /* Print a nice representation of the USERID and make sure it is
2627    displayed in a proper way, which does mean to reorder some parts
2628    for S/MIME's DNs.  USERID is a string as returned by the gpgme key
2629    functions.  It is utf-8 encoded. */
2630 static void parse_and_print_user_id (FILE * fp, const char *userid)
2631 {
2632   const char *s;
2633   int i;
2634
2635   if (*userid == '<') {
2636     s = strchr (userid + 1, '>');
2637     if (s)
2638       print_utf8 (fp, userid + 1, s - userid - 1);
2639   }
2640   else if (*userid == '(')
2641     fputs (_("[Can't display this user ID (unknown encoding)]"), fp);
2642   else if (!digit_or_letter ((const unsigned char *) userid))
2643     fputs (_("[Can't display this user ID (invalid encoding)]"), fp);
2644   else {
2645     struct dn_array_s *dn = parse_dn ((const unsigned char *) userid);
2646
2647     if (!dn)
2648       fputs (_("[Can't display this user ID (invalid DN)]"), fp);
2649     else {
2650       print_dn_parts (fp, dn);
2651       for (i = 0; dn[i].key; i++) {
2652         p_delete(&dn[i].key);
2653         p_delete(&dn[i].value);
2654       }
2655       p_delete(&dn);
2656     }
2657   }
2658 }
2659
2660 typedef enum {
2661   KEY_CAP_CAN_ENCRYPT,
2662   KEY_CAP_CAN_SIGN,
2663   KEY_CAP_CAN_CERTIFY
2664 } key_cap_t;
2665
2666 static unsigned int key_check_cap (gpgme_key_t key, key_cap_t cap)
2667 {
2668   gpgme_subkey_t subkey = NULL;
2669   unsigned int ret = 0;
2670
2671   switch (cap) {
2672   case KEY_CAP_CAN_ENCRYPT:
2673     if (!(ret = key->can_encrypt))
2674       for (subkey = key->subkeys; subkey; subkey = subkey->next)
2675         if ((ret = subkey->can_encrypt))
2676           break;
2677     break;
2678   case KEY_CAP_CAN_SIGN:
2679     if (!(ret = key->can_sign))
2680       for (subkey = key->subkeys; subkey; subkey = subkey->next)
2681         if ((ret = subkey->can_sign))
2682           break;
2683     break;
2684   case KEY_CAP_CAN_CERTIFY:
2685     if (!(ret = key->can_certify))
2686       for (subkey = key->subkeys; subkey; subkey = subkey->next)
2687         if ((ret = subkey->can_certify))
2688           break;
2689     break;
2690   }
2691
2692   return ret;
2693 }
2694
2695
2696 /* Print verbose information about a key or certificate to FP. */
2697 static void print_key_info (gpgme_key_t key, FILE * fp)
2698 {
2699   int idx;
2700   const char *s = NULL, *s2 = NULL;
2701   time_t tt = 0;
2702   struct tm *tm;
2703   char shortbuf[STRING];
2704   unsigned long aval = 0;
2705   const char *delim;
2706   int is_pgp = 0;
2707   int i;
2708   gpgme_user_id_t uid = NULL;
2709
2710   if (Locale)
2711     setlocale (LC_TIME, Locale);
2712
2713   is_pgp = key->protocol == GPGME_PROTOCOL_OpenPGP;
2714
2715   for (idx = 0, uid = key->uids; uid; idx++, uid = uid->next) {
2716     if (uid->revoked)
2717       continue;
2718
2719     s = uid->uid;
2720     fputs (idx ? _(" aka ......: ") :_("Name ......: "), fp);
2721
2722     if (uid->invalid) {
2723       fputs (_("[Invalid]"), fp);
2724       putc (' ', fp);
2725     }
2726     if (is_pgp)
2727       print_utf8 (fp, s, m_strlen(s));
2728     else
2729       parse_and_print_user_id (fp, s);
2730     putc ('\n', fp);
2731   }
2732
2733   if (key->subkeys && (key->subkeys->timestamp > 0)) {
2734     tt = key->subkeys->timestamp;
2735
2736     tm = localtime (&tt);
2737 #ifdef HAVE_LANGINFO_D_T_FMT
2738     strftime (shortbuf, sizeof shortbuf, nl_langinfo (D_T_FMT), tm);
2739 #else
2740     strftime (shortbuf, sizeof shortbuf, "%c", tm);
2741 #endif
2742     fprintf (fp, _("Valid From : %s\n"), shortbuf);
2743   }
2744
2745   if (key->subkeys && (key->subkeys->expires > 0)) {
2746     tt = key->subkeys->expires;
2747
2748     tm = localtime (&tt);
2749 #ifdef HAVE_LANGINFO_D_T_FMT
2750     strftime (shortbuf, sizeof shortbuf, nl_langinfo (D_T_FMT), tm);
2751 #else
2752     strftime (shortbuf, sizeof shortbuf, "%c", tm);
2753 #endif
2754     fprintf (fp, _("Valid To ..: %s\n"), shortbuf);
2755   }
2756
2757   if (key->subkeys)
2758     s = gpgme_pubkey_algo_name (key->subkeys->pubkey_algo);
2759   else
2760     s = "?";
2761
2762   s2 = is_pgp ? "PGP" : "X.509";
2763
2764   if (key->subkeys)
2765     aval = key->subkeys->length;
2766
2767   fprintf (fp, _("Key Type ..: %s, %lu bit %s\n"), s2, aval, s);
2768
2769   fprintf (fp, _("Key Usage .: "));
2770   delim = "";
2771
2772   if (key_check_cap (key, KEY_CAP_CAN_ENCRYPT)) {
2773     fprintf (fp, "%s%s", delim, _("encryption"));
2774     delim = _(", ");
2775   }
2776   if (key_check_cap (key, KEY_CAP_CAN_SIGN)) {
2777     fprintf (fp, "%s%s", delim, _("signing"));
2778     delim = _(", ");
2779   }
2780   if (key_check_cap (key, KEY_CAP_CAN_CERTIFY)) {
2781     fprintf (fp, "%s%s", delim, _("certification"));
2782     delim = _(", ");
2783   }
2784   putc ('\n', fp);
2785
2786   if (key->subkeys) {
2787     s = key->subkeys->fpr;
2788     fputs (_("Fingerprint: "), fp);
2789     if (is_pgp && m_strlen(s) == 40) {
2790       for (i = 0; *s && s[1] && s[2] && s[3] && s[4]; s += 4, i++) {
2791         putc (*s, fp);
2792         putc (s[1], fp);
2793         putc (s[2], fp);
2794         putc (s[3], fp);
2795         putc (is_pgp ? ' ' : ':', fp);
2796         if (is_pgp && i == 4)
2797           putc (' ', fp);
2798       }
2799     }
2800     else {
2801       for (i = 0; *s && s[1] && s[2]; s += 2, i++) {
2802         putc (*s, fp);
2803         putc (s[1], fp);
2804         putc (is_pgp ? ' ' : ':', fp);
2805         if (is_pgp && i == 7)
2806           putc (' ', fp);
2807       }
2808     }
2809     fprintf (fp, "%s\n", s);
2810   }
2811
2812   if (key->issuer_serial) {
2813     s = key->issuer_serial;
2814     if (s)
2815       fprintf (fp, _("Serial-No .: 0x%s\n"), s);
2816   }
2817
2818   if (key->issuer_name) {
2819     s = key->issuer_name;
2820     if (s) {
2821       fprintf (fp, _("Issued By .: "));
2822       parse_and_print_user_id (fp, s);
2823       putc ('\n', fp);
2824     }
2825   }
2826
2827   /* For PGP we list all subkeys. */
2828   if (is_pgp) {
2829     gpgme_subkey_t subkey = NULL;
2830
2831     for (idx = 1, subkey = key->subkeys; subkey; idx++, subkey = subkey->next) {
2832       s = subkey->keyid;
2833
2834       putc ('\n', fp);
2835       if (m_strlen(s) == 16)
2836         s += 8;                 /* display only the short keyID */
2837       fprintf (fp, _("Subkey ....: 0x%s"), s);
2838       if (subkey->revoked) {
2839         putc (' ', fp);
2840         fputs (_("[Revoked]"), fp);
2841       }
2842       if (subkey->invalid) {
2843         putc (' ', fp);
2844         fputs (_("[Invalid]"), fp);
2845       }
2846       if (subkey->expired) {
2847         putc (' ', fp);
2848         fputs (_("[Expired]"), fp);
2849       }
2850       if (subkey->disabled) {
2851         putc (' ', fp);
2852         fputs (_("[Disabled]"), fp);
2853       }
2854       putc ('\n', fp);
2855
2856       if (subkey->timestamp > 0) {
2857         tt = subkey->timestamp;
2858
2859         tm = localtime (&tt);
2860 #ifdef HAVE_LANGINFO_D_T_FMT
2861         strftime (shortbuf, sizeof shortbuf, nl_langinfo (D_T_FMT), tm);
2862 #else
2863         strftime (shortbuf, sizeof shortbuf, "%c", tm);
2864 #endif
2865         fprintf (fp, _("Valid From : %s\n"), shortbuf);
2866       }
2867
2868       if (subkey->expires > 0) {
2869         tt = subkey->expires;
2870
2871         tm = localtime (&tt);
2872 #ifdef HAVE_LANGINFO_D_T_FMT
2873         strftime (shortbuf, sizeof shortbuf, nl_langinfo (D_T_FMT), tm);
2874 #else
2875         strftime (shortbuf, sizeof shortbuf, "%c", tm);
2876 #endif
2877         fprintf (fp, _("Valid To ..: %s\n"), shortbuf);
2878       }
2879
2880       if (subkey)
2881         s = gpgme_pubkey_algo_name (subkey->pubkey_algo);
2882       else
2883         s = "?";
2884
2885       if (subkey)
2886         aval = subkey->length;
2887       else
2888         aval = 0;
2889
2890       fprintf (fp, _("Key Type ..: %s, %lu bit %s\n"), "PGP", aval, s);
2891
2892       fprintf (fp, _("Key Usage .: "));
2893       delim = "";
2894
2895       if (subkey->can_encrypt) {
2896         fprintf (fp, "%s%s", delim, _("encryption"));
2897         delim = _(", ");
2898       }
2899       if (subkey->can_sign) {
2900         fprintf (fp, "%s%s", delim, _("signing"));
2901         delim = _(", ");
2902       }
2903       if (subkey->can_certify) {
2904         fprintf (fp, "%s%s", delim, _("certification"));
2905         delim = _(", ");
2906       }
2907       putc ('\n', fp);
2908     }
2909   }
2910
2911   if (Locale)
2912     setlocale (LC_TIME, "C");
2913 }
2914
2915
2916 /* Show detailed information about the selected key */
2917 static void verify_key (crypt_key_t * key)
2918 {
2919   FILE *fp;
2920   char cmd[LONG_STRING], tempfile[_POSIX_PATH_MAX];
2921   const char *s;
2922   gpgme_ctx_t listctx = NULL;
2923   gpgme_error_t err;
2924   gpgme_key_t k = NULL;
2925   int maxdepth = 100;
2926
2927   fp = m_tempfile (tempfile, sizeof(tempfile), NONULL(Tempdir), NULL);
2928   if (!fp) {
2929     mutt_perror (_("Can't create temporary file"));
2930     return;
2931   }
2932   mutt_message _("Collecting data...");
2933
2934   print_key_info (key->kobj, fp);
2935
2936   err = gpgme_new (&listctx);
2937   if (err) {
2938     fprintf (fp, "Internal error: can't create gpgme context: %s\n",
2939              gpgme_strerror (err));
2940     goto leave;
2941   }
2942   if ((key->flags & KEYFLAG_ISX509))
2943     gpgme_set_protocol (listctx, GPGME_PROTOCOL_CMS);
2944
2945   k = key->kobj;
2946   gpgme_key_ref (k);
2947   while ((s = k->chain_id) && k->subkeys && m_strcmp(s, k->subkeys->fpr)) {
2948     putc ('\n', fp);
2949     err = gpgme_op_keylist_start (listctx, s, 0);
2950     gpgme_key_release (k);
2951     k = NULL;
2952     if (!err)
2953       err = gpgme_op_keylist_next (listctx, &k);
2954     if (err) {
2955       fprintf (fp, _("Error finding issuer key: %s\n"), gpgme_strerror (err));
2956       goto leave;
2957     }
2958     gpgme_op_keylist_end (listctx);
2959
2960     print_key_info (k, fp);
2961     if (!--maxdepth) {
2962       putc ('\n', fp);
2963       fputs (_("Error: certification chain to long - stopping here\n"), fp);
2964       break;
2965     }
2966   }
2967
2968 leave:
2969   gpgme_key_release (k);
2970   gpgme_release (listctx);
2971   m_fclose(&fp);
2972   mutt_clear_error ();
2973   snprintf (cmd, sizeof (cmd), _("Key ID: 0x%s"), crypt_keyid (key));
2974   mutt_do_pager (cmd, tempfile, 0, NULL);
2975 }
2976
2977 /*
2978  * Implementation of `findkeys'.
2979  */
2980
2981
2982 /* Convert string_list_t into a pattern string suitable to be passed to GPGME.
2983    We need to convert spaces in an item into a '+' and '%' into
2984    "%25". */
2985 static char *list_to_pattern (string_list_t * list)
2986 {
2987   string_list_t *l;
2988   char *pattern, *p;
2989   const char *s;
2990   ssize_t n;
2991
2992   n = 0;
2993   for (l = list; l; l = l->next) {
2994     for (s = l->data; *s; s++) {
2995       if (*s == '%')
2996         n += 2;
2997       n++;
2998     }
2999     n++;                        /* delimiter or end of string */
3000   }
3001   n++;                          /* make sure to allocate at least one byte */
3002   pattern = p = p_new(char, n);
3003   for (l = list; l; l = l->next) {
3004     s = l->data;
3005     if (*s) {
3006       if (l != list)
3007         *p++ = ' ';
3008       for (s = l->data; *s; s++) {
3009         if (*s == '%') {
3010           *p++ = '%';
3011           *p++ = '2';
3012           *p++ = '5';
3013         }
3014         else if (*s == '+') {
3015           *p++ = '%';
3016           *p++ = '2';
3017           *p++ = 'B';
3018         }
3019         else if (*s == ' ')
3020           *p++ = '+';
3021         else
3022           *p++ = *s;
3023       }
3024     }
3025   }
3026   *p = 0;
3027   return pattern;
3028 }
3029
3030 /* Return a list of keys which are candidates for the selection.
3031    Select by looking at the HINTS list. */
3032 static crypt_key_t *get_candidates (string_list_t * hints, unsigned int app,
3033                                     int secret)
3034 {
3035   crypt_key_t *db, *k, **kend;
3036   char *pattern;
3037   gpgme_error_t err;
3038   gpgme_ctx_t ctx;
3039   gpgme_key_t key;
3040   int idx;
3041   gpgme_user_id_t uid = NULL;
3042
3043   pattern = list_to_pattern (hints);
3044   if (!pattern)
3045     return NULL;
3046
3047   err = gpgme_new (&ctx);
3048   if (err) {
3049     mutt_error (_("gpgme_new failed: %s"), gpgme_strerror (err));
3050     p_delete(&pattern);
3051     return NULL;
3052   }
3053
3054   db = NULL;
3055   kend = &db;
3056
3057   if ((app & APPLICATION_PGP)) {
3058     /* Its all a mess.  That old GPGME expects different things
3059        depending on the protocol.  For gpg we don' t need percent
3060        escaped pappert but simple strings passed in an array to the
3061        keylist_ext_start function. */
3062     string_list_t *l;
3063     ssize_t n;
3064     char **patarr;
3065
3066     for (l = hints, n = 0; l; l = l->next) {
3067       if (l->data && *l->data)
3068         n++;
3069     }
3070     if (!n)
3071       goto no_pgphints;
3072
3073     patarr = p_new(char *, n + 1);
3074     for (l = hints, n = 0; l; l = l->next) {
3075       if (l->data && *l->data)
3076         patarr[n++] = m_strdup(l->data);
3077     }
3078     patarr[n] = NULL;
3079     err = gpgme_op_keylist_ext_start (ctx, (const char **) patarr, secret, 0);
3080     for (n = 0; patarr[n]; n++)
3081       p_delete(&patarr[n]);
3082     p_delete(&patarr);
3083     if (err) {
3084       mutt_error (_("gpgme_op_keylist_start failed: %s"), gpgme_strerror (err));
3085       gpgme_release (ctx);
3086       p_delete(&pattern);
3087       return NULL;
3088     }
3089
3090     while (!(err = gpgme_op_keylist_next (ctx, &key))) {
3091       unsigned int flags = 0;
3092
3093       if (key_check_cap (key, KEY_CAP_CAN_ENCRYPT))
3094         flags |= KEYFLAG_CANENCRYPT;
3095       if (key_check_cap (key, KEY_CAP_CAN_SIGN))
3096         flags |= KEYFLAG_CANSIGN;
3097
3098 #if 0                           /* DISABLED code */
3099       if (!flags) {
3100         /* Bug in gpg.  Capabilities are not listed for secret
3101            keys.  Try to deduce them from the algorithm. */
3102
3103         switch (key->subkeys[0].pubkey_algo) {
3104         case GPGME_PK_RSA:
3105           flags |= KEYFLAG_CANENCRYPT;
3106           flags |= KEYFLAG_CANSIGN;
3107           break;
3108         case GPGME_PK_ELG_E:
3109           flags |= KEYFLAG_CANENCRYPT;
3110           break;
3111         case GPGME_PK_DSA:
3112           flags |= KEYFLAG_CANSIGN;
3113           break;
3114         }
3115       }
3116 #endif /* DISABLED code */
3117
3118       for (idx = 0, uid = key->uids; uid; idx++, uid = uid->next) {
3119         k = p_new(crypt_key_t, 1);
3120         k->kobj = key;
3121         k->idx = idx;
3122         k->uid = uid->uid;
3123         k->flags = flags;
3124         *kend = k;
3125         kend = &k->next;
3126       }
3127     }
3128     if (gpg_err_code (err) != GPG_ERR_EOF)
3129       mutt_error (_("gpgme_op_keylist_next failed: %s"), gpgme_strerror (err));
3130     gpgme_op_keylist_end (ctx);
3131   no_pgphints:
3132     ;
3133   }
3134
3135   if ((app & APPLICATION_SMIME)) {
3136     /* and now look for x509 certificates */
3137     gpgme_set_protocol (ctx, GPGME_PROTOCOL_CMS);
3138     err = gpgme_op_keylist_start (ctx, pattern, 0);
3139     if (err) {
3140       mutt_error (_("gpgme_op_keylist_start failed: %s"), gpgme_strerror (err));
3141       gpgme_release (ctx);
3142       p_delete(&pattern);
3143       return NULL;
3144     }
3145
3146     while (!(err = gpgme_op_keylist_next (ctx, &key))) {
3147       unsigned int flags = KEYFLAG_ISX509;
3148
3149       if (key_check_cap (key, KEY_CAP_CAN_ENCRYPT))
3150         flags |= KEYFLAG_CANENCRYPT;
3151       if (key_check_cap (key, KEY_CAP_CAN_SIGN))
3152         flags |= KEYFLAG_CANSIGN;
3153
3154       for (idx = 0, uid = key->uids; uid; idx++, uid = uid->next) {
3155         k = p_new(crypt_key_t, 1);
3156         k->kobj = key;
3157         k->idx = idx;
3158         k->uid = uid->uid;
3159         k->flags = flags;
3160         *kend = k;
3161         kend = &k->next;
3162       }
3163     }
3164     if (gpg_err_code (err) != GPG_ERR_EOF)
3165       mutt_error (_("gpgme_op_keylist_next failed: %s"), gpgme_strerror (err));
3166     gpgme_op_keylist_end (ctx);
3167   }
3168
3169   gpgme_release (ctx);
3170   p_delete(&pattern);
3171   return db;
3172 }
3173
3174 /* Add the string STR to the list HINTS.  This list is later used to
3175    match addresses. */
3176 static string_list_t *crypt_add_string_to_hints (string_list_t * hints, const char *str)
3177 {
3178   char *scratch;
3179   char *t;
3180
3181   if ((scratch = m_strdup(str)) == NULL)
3182     return hints;
3183
3184   for (t = strtok (scratch, " ,.:\"()<>\n"); t;
3185        t = strtok (NULL, " ,.:\"()<>\n")) {
3186     if (m_strlen(t) > 3)
3187       hints = mutt_add_list(hints, t);
3188   }
3189
3190   p_delete(&scratch);
3191   return hints;
3192 }
3193
3194 /* Display a menu to select a key from the array KEYS. FORCED_VALID
3195    will be set to true on return if the user did override the the
3196    key's validity. */
3197 static crypt_key_t *crypt_select_key (crypt_key_t * keys,
3198                                       address_t * p, const char *s,
3199                                       unsigned int app, int *forced_valid)
3200 {
3201   int keymax;
3202   crypt_key_t **key_table;
3203   MUTTMENU *menu;
3204   int i, done = 0;
3205   char helpstr[STRING], buf[LONG_STRING];
3206   crypt_key_t *k;
3207   int (*f) (const void *, const void *);
3208   int menu_to_use = 0;
3209   int unusable = 0;
3210
3211   *forced_valid = 0;
3212
3213   /* build the key table */
3214   keymax = i = 0;
3215   key_table = NULL;
3216   for (k = keys; k; k = k->next) {
3217     if (!option (OPTPGPSHOWUNUSABLE) && (k->flags & KEYFLAG_CANTUSE)) {
3218       unusable = 1;
3219       continue;
3220     }
3221
3222     if (i == keymax) {
3223       keymax += 20;
3224       p_realloc(&key_table, keymax);
3225     }
3226
3227     key_table[i++] = k;
3228   }
3229
3230   if (!i && unusable) {
3231     mutt_error _("All matching keys are marked expired/revoked.");
3232
3233     mutt_sleep (1);
3234     return NULL;
3235   }
3236
3237   switch (PgpSortKeys & SORT_MASK) {
3238   case SORT_DATE:
3239     f = crypt_compare_date;
3240     break;
3241   case SORT_KEYID:
3242     f = crypt_compare_keyid;
3243     break;
3244   case SORT_ADDRESS:
3245     f = crypt_compare_address;
3246     break;
3247   case SORT_TRUST:
3248   default:
3249     f = crypt_compare_trust;
3250     break;
3251   }
3252   qsort (key_table, i, sizeof (crypt_key_t *), f);
3253
3254   if (app & APPLICATION_PGP)
3255     menu_to_use = MENU_KEY_SELECT_PGP;
3256   else if (app & APPLICATION_SMIME)
3257     menu_to_use = MENU_KEY_SELECT_SMIME;
3258
3259   helpstr[0] = 0;
3260   mutt_make_help (buf, sizeof (buf), _("Exit  "), menu_to_use, OP_EXIT);
3261   m_strcat(helpstr, sizeof(helpstr), buf);
3262   mutt_make_help (buf, sizeof (buf), _("Select  "), menu_to_use,
3263                   OP_GENERIC_SELECT_ENTRY);
3264   m_strcat(helpstr, sizeof(helpstr), buf);
3265   mutt_make_help (buf, sizeof (buf), _("Check key  "),
3266                   menu_to_use, OP_VERIFY_KEY);
3267   m_strcat(helpstr, sizeof(helpstr), buf);
3268   mutt_make_help (buf, sizeof (buf), _("Help"), menu_to_use, OP_HELP);
3269   m_strcat(helpstr, sizeof(helpstr), buf);
3270
3271   menu = mutt_new_menu ();
3272   menu->max = i;
3273   menu->make_entry = crypt_entry;
3274   menu->menu = menu_to_use;
3275   menu->help = helpstr;
3276   menu->data = key_table;
3277
3278   {
3279     const char *ts;
3280
3281     if ((app & APPLICATION_PGP) && (app & APPLICATION_SMIME))
3282       ts = _("PGP and S/MIME keys matching");
3283     else if ((app & APPLICATION_PGP))
3284       ts = _("PGP keys matching");
3285     else if ((app & APPLICATION_SMIME))
3286       ts = _("S/MIME keys matching");
3287     else
3288       ts = _("keys matching");
3289
3290     if (p)
3291       snprintf (buf, sizeof (buf), _("%s <%s>."), ts, p->mailbox);
3292     else
3293       snprintf (buf, sizeof (buf), _("%s \"%s\"."), ts, s);
3294     menu->title = buf;
3295   }
3296
3297   mutt_clear_error ();
3298   k = NULL;
3299   while (!done) {
3300     *forced_valid = 0;
3301     switch (mutt_menuLoop (menu)) {
3302     case OP_VERIFY_KEY:
3303       verify_key (key_table[menu->current]);
3304       menu->redraw = REDRAW_FULL;
3305       break;
3306
3307     case OP_VIEW_ID:
3308       mutt_message ("%s", key_table[menu->current]->uid);
3309       break;
3310
3311     case OP_GENERIC_SELECT_ENTRY:
3312       /* FIXME make error reporting more verbose - this should be
3313          easy because gpgme provides more information */
3314       if (option (OPTPGPCHECKTRUST)) {
3315         if (!crypt_key_is_valid (key_table[menu->current])) {
3316           mutt_error _("This key can't be used: "
3317                        "expired/disabled/revoked.");
3318           break;
3319         }
3320       }
3321
3322       if (option (OPTPGPCHECKTRUST) &&
3323           (!crypt_id_is_valid (key_table[menu->current])
3324            || !crypt_id_is_strong (key_table[menu->current]))) {
3325         const char *warn_s;
3326         char buff[LONG_STRING];
3327
3328         if (key_table[menu->current]->flags & KEYFLAG_CANTUSE)
3329           s = N_("ID is expired/disabled/revoked.");
3330         else {
3331           gpgme_validity_t val = GPGME_VALIDITY_UNKNOWN;
3332           gpgme_user_id_t uid = NULL;
3333           int j = 0;
3334
3335           warn_s = "??";
3336
3337           uid = key_table[menu->current]->kobj->uids;
3338           for (j = 0; (j < key_table[menu->current]->idx) && uid;
3339                j++, uid = uid->next);
3340           if (uid)
3341             val = uid->validity;
3342
3343           switch (val) {
3344           case GPGME_VALIDITY_UNKNOWN:
3345           case GPGME_VALIDITY_UNDEFINED:
3346             warn_s = N_("ID has undefined validity.");
3347             break;
3348           case GPGME_VALIDITY_NEVER:
3349             warn_s = N_("ID is not valid.");
3350             break;
3351           case GPGME_VALIDITY_MARGINAL:
3352             warn_s = N_("ID is only marginally valid.");
3353             break;
3354           case GPGME_VALIDITY_FULL:
3355           case GPGME_VALIDITY_ULTIMATE:
3356             break;
3357           }
3358
3359           snprintf (buff, sizeof (buff),
3360                     _("%s Do you really want to use the key?"), _(warn_s));
3361
3362           if (mutt_yesorno (buff, 0) != 1) {
3363             mutt_clear_error ();
3364             break;
3365           }
3366           *forced_valid = 1;
3367         }
3368       }
3369
3370       k = crypt_copy_key (key_table[menu->current]);
3371       done = 1;
3372       break;
3373
3374     case OP_EXIT:
3375       k = NULL;
3376       done = 1;
3377       break;
3378     }
3379   }
3380
3381   mutt_menuDestroy (&menu);
3382   p_delete(&key_table);
3383
3384   set_option (OPTNEEDREDRAW);
3385
3386   return k;
3387 }
3388
3389 static crypt_key_t *crypt_getkeybyaddr (address_t * a, short abilities,
3390                                         unsigned int app, int *forced_valid)
3391 {
3392   address_t *r, *p;
3393   string_list_t *hints = NULL;
3394
3395   int weak = 0;
3396   int invalid = 0;
3397   int multi = 0;
3398   int this_key_has_strong;
3399   int this_key_has_weak;
3400   int this_key_has_invalid;
3401   int match;
3402
3403   crypt_key_t *keys, *k;
3404   crypt_key_t *the_valid_key = NULL;
3405   crypt_key_t *matches = NULL;
3406   crypt_key_t **matches_endp = &matches;
3407
3408   *forced_valid = 0;
3409
3410   if (a && a->mailbox)
3411     hints = crypt_add_string_to_hints (hints, a->mailbox);
3412   if (a && a->personal)
3413     hints = crypt_add_string_to_hints (hints, a->personal);
3414
3415   mutt_message (_("Looking for keys matching \"%s\"..."), a->mailbox);
3416   keys = get_candidates (hints, app, (abilities & KEYFLAG_CANSIGN));
3417
3418   string_list_wipe(&hints);
3419
3420   if (!keys)
3421     return NULL;
3422
3423   for (k = keys; k; k = k->next) {
3424     if (abilities && !(k->flags & abilities)) {
3425       continue;
3426     }
3427
3428     this_key_has_weak = 0;      /* weak but valid match   */
3429     this_key_has_invalid = 0;   /* invalid match          */
3430     this_key_has_strong = 0;    /* strong and valid match */
3431     match = 0;                  /* any match            */
3432
3433     r = rfc822_parse_adrlist (NULL, k->uid);
3434     for (p = r; p; p = p->next) {
3435       int validity = crypt_id_matches_addr (a, p, k);
3436
3437       if (validity & CRYPT_KV_MATCH)    /* something matches */
3438         match = 1;
3439
3440       /* is this key a strong candidate? */
3441       if ((validity & CRYPT_KV_VALID)
3442           && (validity & CRYPT_KV_STRONGID)
3443           && (validity & CRYPT_KV_ADDR)) {
3444         if (the_valid_key && the_valid_key != k)
3445           multi = 1;
3446         the_valid_key = k;
3447         this_key_has_strong = 1;
3448       }
3449       else if ((validity & CRYPT_KV_MATCH)
3450                && !(validity & CRYPT_KV_VALID))
3451         this_key_has_invalid = 1;
3452       else if ((validity & CRYPT_KV_MATCH)
3453                && (!(validity & CRYPT_KV_STRONGID)
3454                    || !(validity & CRYPT_KV_ADDR)))
3455         this_key_has_weak = 1;
3456     }
3457     address_list_wipe(&r);
3458
3459     if (match) {
3460       crypt_key_t *tmp;
3461
3462       if (!this_key_has_strong && this_key_has_invalid)
3463         invalid = 1;
3464       if (!this_key_has_strong && this_key_has_weak)
3465         weak = 1;
3466
3467       *matches_endp = tmp = crypt_copy_key (k);
3468       matches_endp = &tmp->next;
3469       the_valid_key = tmp;
3470     }
3471   }
3472
3473   crypt_free_key (&keys);
3474
3475   if (matches) {
3476     if (the_valid_key && !multi && !weak
3477         && !(invalid && option (OPTPGPSHOWUNUSABLE))) {
3478       /*
3479        * There was precisely one strong match on a valid ID, there
3480        * were no valid keys with weak matches, and we aren't
3481        * interested in seeing invalid keys.
3482        *
3483        * Proceed without asking the user.
3484        */
3485       k = crypt_copy_key (the_valid_key);
3486     }
3487     else {
3488       /*
3489        * Else: Ask the user.
3490        */
3491       k = crypt_select_key (matches, a, NULL, app, forced_valid);
3492     }
3493     crypt_free_key (&matches);
3494   }
3495   else
3496     k = NULL;
3497
3498   return k;
3499 }
3500
3501
3502 static crypt_key_t *crypt_getkeybystr (const char *p, short abilities,
3503                                        unsigned int app, int *forced_valid)
3504 {
3505   string_list_t *hints = NULL;
3506   crypt_key_t *keys;
3507   crypt_key_t *matches = NULL;
3508   crypt_key_t **matches_endp = &matches;
3509   crypt_key_t *k;
3510   int match;
3511
3512   mutt_message (_("Looking for keys matching \"%s\"..."), p);
3513
3514   *forced_valid = 0;
3515
3516   hints = crypt_add_string_to_hints (hints, p);
3517   keys = get_candidates (hints, app, (abilities & KEYFLAG_CANSIGN));
3518   string_list_wipe(&hints);
3519
3520   if (!keys)
3521     return NULL;
3522
3523   for (k = keys; k; k = k->next) {
3524     if (abilities && !(k->flags & abilities))
3525       continue;
3526
3527     match = 0;
3528
3529     if (!*p || !m_strcasecmp(p, crypt_keyid (k))
3530         || (!m_strncasecmp(p, "0x", 2)
3531             && !m_strcasecmp(p + 2, crypt_keyid (k)))
3532         || (option (OPTPGPLONGIDS)
3533             && !m_strncasecmp(p, "0x", 2)
3534             && !m_strcasecmp(p + 2, crypt_keyid (k) + 8))
3535         || m_stristr(k->uid, p)) {
3536       crypt_key_t *tmp;
3537
3538       *matches_endp = tmp = crypt_copy_key (k);
3539       matches_endp = &tmp->next;
3540     }
3541   }
3542
3543   crypt_free_key (&keys);
3544
3545   if (matches) {
3546     k = crypt_select_key (matches, NULL, p, app, forced_valid);
3547     crypt_free_key (&matches);
3548     return k;
3549   }
3550
3551   return NULL;
3552 }
3553
3554 /* Display TAG as a prompt to ask for a key.  If WHATFOR is not null
3555    use it as default and store it under that label as the next
3556    default.  ABILITIES describe the required key abilities (sign,
3557    encrypt) and APP the type of the requested key; ether S/MIME or
3558    PGP.  Return a copy of the key or NULL if not found. */
3559 static crypt_key_t *crypt_ask_for_key (char *tag,
3560                                        char *whatfor,
3561                                        short abilities,
3562                                        unsigned int app, int *forced_valid)
3563 {
3564   crypt_key_t *key;
3565   char resp[STRING];
3566   struct crypt_cache *l = NULL;
3567   int dummy;
3568
3569   if (!forced_valid)
3570     forced_valid = &dummy;
3571
3572   mutt_clear_error ();
3573
3574   *forced_valid = 0;
3575   resp[0] = 0;
3576   if (whatfor) {
3577
3578     for (l = id_defaults; l; l = l->next)
3579       if (!m_strcasecmp(whatfor, l->what)) {
3580         m_strcpy(resp, sizeof(resp), NONULL(l->dflt));
3581         break;
3582       }
3583   }
3584
3585
3586   for (;;) {
3587     resp[0] = 0;
3588     if (mutt_get_field (tag, resp, sizeof (resp), M_CLEAR) != 0)
3589       return NULL;
3590
3591     if (whatfor) {
3592       if (l)
3593         m_strreplace(&l->dflt, resp);
3594       else {
3595         l = p_new(struct crypt_cache, 1);
3596         l->next = id_defaults;
3597         id_defaults = l;
3598         l->what = m_strdup(whatfor);
3599         l->dflt = m_strdup(resp);
3600       }
3601     }
3602
3603     if ((key = crypt_getkeybystr (resp, abilities, app, forced_valid)))
3604       return key;
3605
3606     BEEP ();
3607   }
3608   /* not reached */
3609 }
3610
3611 /* This routine attempts to find the keyids of the recipients of a
3612    message.  It returns NULL if any of the keys can not be found.  */
3613 static char *find_keys (address_t * to, address_t * cc, address_t * bcc,
3614                         unsigned int app)
3615 {
3616   char *keylist = NULL, *t;
3617   const char *keyID;
3618   ssize_t keylist_size = 0;
3619   ssize_t keylist_used = 0;
3620   address_t *tmp = NULL, *addr = NULL;
3621   address_t **last = &tmp;
3622   address_t *p, *q;
3623   int i;
3624   crypt_key_t *k_info, *key;
3625   const char *fqdn = mutt_fqdn (1);
3626
3627 #if 0
3628   *r_application = APPLICATION_PGP | APPLICATION_SMIME;
3629 #endif
3630
3631   for (i = 0; i < 3; i++) {
3632     switch (i) {
3633     case 0:
3634       p = to;
3635       break;
3636     case 1:
3637       p = cc;
3638       break;
3639     case 2:
3640       p = bcc;
3641       break;
3642     default:
3643       abort ();
3644     }
3645
3646     *last = address_list_dup (p);
3647     while (*last)
3648       last = &((*last)->next);
3649   }
3650
3651   rfc822_qualify(tmp, fqdn);
3652   address_list_uniq(tmp);
3653
3654   for (p = tmp; p; p = p->next) {
3655     char buf[LONG_STRING];
3656     int forced_valid = 0;
3657
3658     q = p;
3659     k_info = NULL;
3660
3661     if ((keyID = mutt_crypt_hook (p)) != NULL) {
3662       int r;
3663
3664       snprintf (buf, sizeof (buf), _("Use keyID = \"%s\" for %s?"),
3665                 keyID, p->mailbox);
3666       if ((r = mutt_yesorno (buf, M_YES)) == M_YES) {
3667         /* check for e-mail address */
3668         if ((t = strchr (keyID, '@')) &&
3669             (addr = rfc822_parse_adrlist (NULL, keyID))) {
3670           rfc822_qualify(addr, fqdn);
3671           q = addr;
3672         }
3673         else {
3674           k_info = crypt_getkeybystr (keyID, KEYFLAG_CANENCRYPT,
3675                                       app, &forced_valid);
3676         }
3677       }
3678       else if (r == -1) {
3679         p_delete(&keylist);
3680         address_list_wipe(&tmp);
3681         address_list_wipe(&addr);
3682         return NULL;
3683       }
3684     }
3685
3686     if (k_info == NULL
3687         && (k_info = crypt_getkeybyaddr (q, KEYFLAG_CANENCRYPT,
3688                                          app, &forced_valid)) == NULL) {
3689       snprintf (buf, sizeof (buf), _("Enter keyID for %s: "), q->mailbox);
3690
3691       if ((key = crypt_ask_for_key (buf, q->mailbox, KEYFLAG_CANENCRYPT,
3692                                     app,
3693                                     &forced_valid)) == NULL) {
3694         p_delete(&keylist);
3695         address_list_wipe(&tmp);
3696         address_list_wipe(&addr);
3697         return NULL;
3698       }
3699     }
3700     else
3701       key = k_info;
3702
3703     {
3704       const char *s = crypt_fpr (key);
3705
3706       keylist_size += m_strlen(s) + 4 + 1;
3707       p_realloc(&keylist, keylist_size);
3708       sprintf (keylist + keylist_used, "%s0x%s%s",
3709                keylist_used ? " " : "", s, forced_valid ? "!" : "");
3710     }
3711     keylist_used = m_strlen(keylist);
3712
3713     crypt_free_key (&key);
3714     address_list_wipe(&addr);
3715   }
3716   address_list_wipe(&tmp);
3717   return (keylist);
3718 }
3719
3720 char *pgp_gpgme_findkeys (address_t * to, address_t * cc, address_t * bcc)
3721 {
3722   return find_keys (to, cc, bcc, APPLICATION_PGP);
3723 }
3724
3725 char *smime_gpgme_findkeys (address_t * to, address_t * cc, address_t * bcc)
3726 {
3727   return find_keys (to, cc, bcc, APPLICATION_SMIME);
3728 }
3729
3730 /*
3731  * Implementation of `init'.
3732  */
3733
3734 /* Initialization.  */
3735 static void init_gpgme (void)
3736 {
3737   /* Make sure that gpg-agent is running.  */
3738   if (!getenv ("GPG_AGENT_INFO")) {
3739     mutt_error ("\nUsing GPGME backend, although no gpg-agent is running");
3740     if (mutt_any_key_to_continue (NULL) == -1)
3741       mutt_exit (1);
3742   }
3743 }
3744
3745 void pgp_gpgme_init (void)
3746 {
3747   init_gpgme ();
3748 }
3749
3750 void smime_gpgme_init (void)
3751 {
3752 }
3753
3754 static int gpgme_send_menu (HEADER * msg, int *redraw, int is_smime)
3755 {
3756   crypt_key_t *p;
3757   char input_signas[STRING];
3758   int choice;
3759
3760   if (msg->security & APPLICATION_PGP)
3761     is_smime = 0;
3762   else if (msg->security & APPLICATION_SMIME)
3763     is_smime = 1;
3764
3765   if (is_smime)
3766     choice =
3767       mutt_multi_choice (_
3768                          ("S/MIME (e)ncrypt, (s)ign, sign (a)s, (b)oth, (p)gp or (c)lear?"),
3769                          _("esabpfc"));
3770   else
3771     choice =
3772       mutt_multi_choice (_
3773                          ("PGP (e)ncrypt, (s)ign, sign (a)s, (b)oth, s/(m)ime or (c)lear?"),
3774                          _("esabmfc"));
3775
3776   switch (choice) {
3777   case 1:                      /* (e)ncrypt */
3778     msg->security |= (is_smime ? SMIMEENCRYPT : PGPENCRYPT);
3779     msg->security &= ~(is_smime ? SMIMESIGN : PGPSIGN);
3780     break;
3781
3782   case 2:                      /* (s)ign */
3783     msg->security |= (is_smime ? SMIMESIGN : PGPSIGN);
3784     msg->security &= ~(is_smime ? SMIMEENCRYPT : PGPENCRYPT);
3785     break;
3786
3787   case 3:                      /* sign (a)s */
3788 /*      unset_option(OPTCRYPTCHECKTRUST); */
3789     if ((p = crypt_ask_for_key (_("Sign as: "), NULL, KEYFLAG_CANSIGN,
3790                                 is_smime ? APPLICATION_SMIME :
3791                                 APPLICATION_PGP, NULL))) {
3792       snprintf (input_signas, sizeof (input_signas), "0x%s", crypt_keyid (p));
3793       m_strreplace(is_smime ? &SmimeDefaultKey : &PgpSignAs,
3794                         input_signas);
3795       crypt_free_key (&p);
3796
3797       msg->security |= (is_smime ? SMIMESIGN : PGPSIGN);
3798     }
3799     *redraw = REDRAW_FULL;
3800     break;
3801
3802   case 4:                      /* (b)oth */
3803     msg->security =
3804       (is_smime ? (SMIMEENCRYPT | SMIMESIGN) : (PGPENCRYPT | PGPSIGN));
3805     break;
3806
3807   case 5:                      /* (p)gp or s/(m)ime */
3808     is_smime = !is_smime;
3809     break;
3810
3811   case 6:                      /* (c)lear */
3812     msg->security = 0;
3813     break;
3814   }
3815
3816   if (choice == 6 || choice == 7);
3817   else if (is_smime) {
3818     msg->security &= ~APPLICATION_PGP;
3819     msg->security |= APPLICATION_SMIME;
3820   }
3821   else {
3822     msg->security &= ~APPLICATION_SMIME;
3823     msg->security |= APPLICATION_PGP;
3824   }
3825
3826   return (msg->security);
3827 }
3828
3829 int pgp_gpgme_send_menu (HEADER * msg, int *redraw)
3830 {
3831   return gpgme_send_menu (msg, redraw, 0);
3832 }
3833
3834 int smime_gpgme_send_menu (HEADER * msg, int *redraw)
3835 {
3836   return gpgme_send_menu (msg, redraw, 1);
3837 }
3838
3839 static int verify_sender (HEADER * h, gpgme_protocol_t protocol __attribute__((unused)))
3840 {
3841   address_t *sender = NULL;
3842   unsigned int ret = 1;
3843
3844   if (h->env->from) {
3845     h->env->from = mutt_expand_aliases (h->env->from);
3846     sender = h->env->from;
3847   }
3848   else if (h->env->sender) {
3849     h->env->sender = mutt_expand_aliases (h->env->sender);
3850     sender = h->env->sender;
3851   }
3852
3853   if (sender) {
3854     if (signature_key) {
3855       gpgme_key_t key = signature_key;
3856       gpgme_user_id_t uid = NULL;
3857       int sender_length = 0;
3858       int uid_length = 0;
3859
3860       sender_length = m_strlen(sender->mailbox);
3861       for (uid = key->uids; uid && ret; uid = uid->next) {
3862         uid_length = m_strlen(uid->email);
3863         if (1 && (uid->email[0] == '<')
3864             && (uid->email[uid_length - 1] == '>')
3865             && (uid_length == sender_length + 2)
3866             && (!m_strncmp (uid->email + 1, sender->mailbox, sender_length)))
3867           ret = 0;
3868       }
3869     }
3870     else
3871       mutt_any_key_to_continue ("Failed to verify sender");
3872   }
3873   else
3874     mutt_any_key_to_continue ("Failed to figure out sender");
3875
3876   if (signature_key) {
3877     gpgme_key_release (signature_key);
3878     signature_key = NULL;
3879   }
3880
3881   return ret;
3882 }
3883
3884 int smime_gpgme_verify_sender (HEADER * h)
3885 {
3886   return verify_sender (h, GPGME_PROTOCOL_CMS);
3887 }
3888
3889 #endif