pgpkey.c

   1 /*
   2  * Copyright (C) 1996-7,2007 Michael R. Elkins <me@mutt.org>
   3  * Copyright (c) 1998-2003 Thomas Roessler <roessler@does-not-exist.org>
   4  *
   5  *     This program is free software; you can redistribute it
   6  *     and/or modify it under the terms of the GNU General Public
   7  *     License as published by the Free Software Foundation; either
   8  *     version 2 of the License, or (at your option) any later
   9  *     version.
  10  *
  11  *     This program is distributed in the hope that it will be
  12  *     useful, but WITHOUT ANY WARRANTY; without even the implied
  13  *     warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14  *     PURPOSE.  See the GNU General Public License for more
  15  *     details.
  16  *
  17  *     You should have received a copy of the GNU General Public
  18  *     License along with this program; if not, write to the Free
  19  *     Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  20  *     Boston, MA  02110-1301, USA.
  21  */
  22
  23 #if HAVE_CONFIG_H
  24 # include "config.h"
  25 #endif
  26
  27 #include "mutt.h"
  28 #include "mutt_curses.h"
  29 #include "mutt_menu.h"
  30 #include "mime.h"
  31 #include "pgp.h"
  32 #include "pager.h"
  33 #include "sort.h"
  34
  35 #include <string.h>
  36 #include <ctype.h>
  37 #include <stdlib.h>
  38 #include <unistd.h>
  39 #include <sys/stat.h>
  40 #include <sys/wait.h>
  41
  42 #include <locale.h>
  43
  44 #ifdef CRYPT_BACKEND_CLASSIC_PGP
  45
  46 struct pgp_cache
  47 {
  48   char *what;
  49   char *dflt;
  50   struct pgp_cache *next;
  51 };
  52
  53 static struct pgp_cache *id_defaults = NULL;
  54
  55 static char trust_flags[] = "?- +";
  56
  57 static char *pgp_key_abilities (int flags)
  58 {
  59   static char buff[3];
  60
  61   if (!(flags & KEYFLAG_CANENCRYPT))
  62     buff[0] = '-';
  63   else if (flags & KEYFLAG_PREFER_SIGNING)
  64     buff[0] = '.';
  65   else
  66     buff[0] = 'e';
  67
  68   if (!(flags & KEYFLAG_CANSIGN))
  69     buff[1] = '-';
  70   else if (flags & KEYFLAG_PREFER_ENCRYPTION)
  71     buff[1] = '.';
  72   else
  73     buff[1] = 's';
  74
  75   buff[2] = '\0';
  76
  77   return buff;
  78 }
  79
  80 static char pgp_flags (int flags)
  81 {
  82   if (flags & KEYFLAG_REVOKED)
  83     return 'R';
  84   else if (flags & KEYFLAG_EXPIRED)
  85     return 'X';
  86   else if (flags & KEYFLAG_DISABLED)
  87     return 'd';
  88   else if (flags & KEYFLAG_CRITICAL)
  89     return 'c';
  90   else
  91     return ' ';
  92 }
  93
  94 static pgp_key_t pgp_principal_key (pgp_key_t key)
  95 {
  96   if (key->flags & KEYFLAG_SUBKEY && key->parent)
  97     return key->parent;
  98   else
  99     return key;
 100 }
 101
 102 /*
 103  * Format an entry on the PGP key selection menu.
 104  *
 105  * %n   number
 106  * %k   key id          %K      key id of the principal key
 107  * %u   user id
 108  * %a   algorithm       %A      algorithm of the princ. key
 109  * %l   length          %L      length of the princ. key
 110  * %f   flags           %F      flags of the princ. key
 111  * %c   capabilities    %C      capabilities of the princ. key
 112  * %t   trust/validity of the key-uid association
 113  * %[...] date of key using strftime(3)
 114  */
 115
 116 typedef struct pgp_entry
 117 {
 118   size_t num;
 119   pgp_uid_t *uid;
 120 } pgp_entry_t;
 121
 122 static const char *pgp_entry_fmt (char *dest,
 123                                   size_t destlen,
 124                                   size_t col,
 125                                   char op,
 126                                   const char *src,
 127                                   const char *prefix,
 128                                   const char *ifstring,
 129                                   const char *elsestring,
 130                                   unsigned long data,
 131                                   format_flag flags)
 132 {
 133   char fmt[16];
 134   pgp_entry_t *entry;
 135   pgp_uid_t *uid;
 136   pgp_key_t key, pkey;
 137   int kflags = 0;
 138   int optional = (flags & M_FORMAT_OPTIONAL);
 139
 140   entry = (pgp_entry_t *) data;
 141   uid   = entry->uid;
 142   key   = uid->parent;
 143   pkey  = pgp_principal_key (key);
 144
 145   if (isupper ((unsigned char) op))
 146     key = pkey;
 147
 148   kflags = key->flags | (pkey->flags & KEYFLAG_RESTRICTIONS)
 149     | uid->flags;
 150
 151   switch (ascii_tolower (op))
 152   {
 153     case '[':
 154
 155       {
 156         const char *cp;
 157         char buf2[SHORT_STRING], *p;
 158         int do_locales;
 159         struct tm *tm;
 160         size_t len;
 161
 162         p = dest;
 163
 164         cp = src;
 165         if (*cp == '!')
 166         {
 167           do_locales = 0;
 168           cp++;
 169         }
 170         else
 171           do_locales = 1;
 172
 173         len = destlen - 1;
 174         while (len > 0 && *cp != ']')
 175         {
 176           if (*cp == '%')
 177           {
 178             cp++;
 179             if (len >= 2)
 180             {
 181               *p++ = '%';
 182               *p++ = *cp;
 183               len -= 2;
 184             }
 185             else
 186               break; /* not enough space */
 187             cp++;
 188           }
 189           else
 190           {
 191             *p++ = *cp++;
 192             len--;
 193           }
 194         }
 195         *p = 0;
 196
 197         if (do_locales && Locale)
 198           setlocale (LC_TIME, Locale);
 199
 200         tm = localtime (&key->gen_time);
 201
 202         strftime (buf2, sizeof (buf2), dest, tm);
 203
 204         if (do_locales)
 205           setlocale (LC_TIME, "C");
 206
 207         snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
 208         snprintf (dest, destlen, fmt, buf2);
 209         if (len > 0)
 210           src = cp + 1;
 211       }
 212       break;
 213     case 'n':
 214       if (!optional)
 215       {
 216         snprintf (fmt, sizeof (fmt), "%%%sd", prefix);
 217         snprintf (dest, destlen, fmt, entry->num);
 218       }
 219       break;
 220     case 'k':
 221       if (!optional)
 222       {
 223         snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
 224         snprintf (dest, destlen, fmt, _pgp_keyid (key));
 225       }
 226       break;
 227     case 'u':
 228       if (!optional)
 229       {
 230         snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
 231         snprintf (dest, destlen, fmt, uid->addr);
 232       }
 233       break;
 234     case 'a':
 235       if (!optional)
 236       {
 237         snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
 238         snprintf (dest, destlen, fmt, key->algorithm);
 239       }
 240       break;
 241     case 'l':
 242       if (!optional)
 243       {
 244         snprintf (fmt, sizeof (fmt), "%%%sd", prefix);
 245         snprintf (dest, destlen, fmt, key->keylen);
 246       }
 247       break;
 248     case 'f':
 249       if (!optional)
 250       {
 251         snprintf (fmt, sizeof (fmt), "%%%sc", prefix);
 252         snprintf (dest, destlen, fmt, pgp_flags (kflags));
 253       }
 254       else if (!(kflags & (KEYFLAG_RESTRICTIONS)))
 255         optional = 0;
 256       break;
 257     case 'c':
 258       if (!optional)
 259       {
 260         snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
 261         snprintf (dest, destlen, fmt, pgp_key_abilities (kflags));
 262       }
 263       else if (!(kflags & (KEYFLAG_ABILITIES)))
 264         optional = 0;
 265       break;
 266     case 't':
 267       if (!optional)
 268       {
 269         snprintf (fmt, sizeof (fmt), "%%%sc", prefix);
 270         snprintf (dest, destlen, fmt, trust_flags[uid->trust & 0x03]);
 271       }
 272       else if (!(uid->trust & 0x03))
 273         /* undefined trust */
 274         optional = 0;
 275       break;
 276     default:
 277       *dest = '\0';
 278   }
 279
 280   if (optional)
 281     mutt_FormatString (dest, destlen, col, ifstring, mutt_attach_fmt, data, 0);
 282   else if (flags & M_FORMAT_OPTIONAL)
 283     mutt_FormatString (dest, destlen, col, elsestring, mutt_attach_fmt, data, 0);
 284   return (src);
 285 }
 286
 287 static void pgp_entry (char *s, size_t l, MUTTMENU * menu, int num)
 288 {
 289   pgp_uid_t **KeyTable = (pgp_uid_t **) menu->data;
 290   pgp_entry_t entry;
 291
 292   entry.uid = KeyTable[num];
 293   entry.num = num + 1;
 294
 295   mutt_FormatString (s, l, 0, NONULL (PgpEntryFormat), pgp_entry_fmt,
 296                      (unsigned long) &entry, M_FORMAT_ARROWCURSOR);
 297 }
 298
 299 static int _pgp_compare_address (const void *a, const void *b)
 300 {
 301   int r;
 302
 303   pgp_uid_t **s = (pgp_uid_t **) a;
 304   pgp_uid_t **t = (pgp_uid_t **) b;
 305
 306   if ((r = mutt_strcasecmp ((*s)->addr, (*t)->addr)))
 307     return r > 0;
 308   else
 309     return (mutt_strcasecmp (_pgp_keyid ((*s)->parent),
 310                              _pgp_keyid ((*t)->parent)) > 0);
 311 }
 312
 313 static int pgp_compare_address (const void *a, const void *b)
 314 {
 315   return ((PgpSortKeys & SORT_REVERSE) ? !_pgp_compare_address (a, b)
 316                                        : _pgp_compare_address (a, b));
 317 }
 318
 319
 320
 321 static int _pgp_compare_keyid (const void *a, const void *b)
 322 {
 323   int r;
 324
 325   pgp_uid_t **s = (pgp_uid_t **) a;
 326   pgp_uid_t **t = (pgp_uid_t **) b;
 327
 328   if ((r = mutt_strcasecmp (_pgp_keyid ((*s)->parent),
 329                             _pgp_keyid ((*t)->parent))))
 330     return r > 0;
 331   else
 332     return (mutt_strcasecmp ((*s)->addr, (*t)->addr)) > 0;
 333 }
 334
 335 static int pgp_compare_keyid (const void *a, const void *b)
 336 {
 337   return ((PgpSortKeys & SORT_REVERSE) ? !_pgp_compare_keyid (a, b)
 338                                        : _pgp_compare_keyid (a, b));
 339 }
 340
 341 static int _pgp_compare_date (const void *a, const void *b)
 342 {
 343   int r;
 344   pgp_uid_t **s = (pgp_uid_t **) a;
 345   pgp_uid_t **t = (pgp_uid_t **) b;
 346
 347   if ((r = ((*s)->parent->gen_time - (*t)->parent->gen_time)))
 348     return r > 0;
 349   return (mutt_strcasecmp ((*s)->addr, (*t)->addr)) > 0;
 350 }
 351
 352 static int pgp_compare_date (const void *a, const void *b)
 353 {
 354   return ((PgpSortKeys & SORT_REVERSE) ? !_pgp_compare_date (a, b)
 355                                        : _pgp_compare_date (a, b));
 356 }
 357
 358 static int _pgp_compare_trust (const void *a, const void *b)
 359 {
 360   int r;
 361
 362   pgp_uid_t **s = (pgp_uid_t **) a;
 363   pgp_uid_t **t = (pgp_uid_t **) b;
 364
 365   if ((r = (((*s)->parent->flags & (KEYFLAG_RESTRICTIONS))
 366             - ((*t)->parent->flags & (KEYFLAG_RESTRICTIONS)))))
 367     return r > 0;
 368   if ((r = ((*s)->trust - (*t)->trust)))
 369     return r < 0;
 370   if ((r = ((*s)->parent->keylen - (*t)->parent->keylen)))
 371     return r < 0;
 372   if ((r = ((*s)->parent->gen_time - (*t)->parent->gen_time)))
 373     return r < 0;
 374   if ((r = mutt_strcasecmp ((*s)->addr, (*t)->addr)))
 375     return r > 0;
 376   return (mutt_strcasecmp (_pgp_keyid ((*s)->parent),
 377                            _pgp_keyid ((*t)->parent))) > 0;
 378 }
 379
 380 static int pgp_compare_trust (const void *a, const void *b)
 381 {
 382   return ((PgpSortKeys & SORT_REVERSE) ? !_pgp_compare_trust (a, b)
 383                                        : _pgp_compare_trust (a, b));
 384 }
 385
 386 static int pgp_key_is_valid (pgp_key_t k)
 387 {
 388   pgp_key_t pk = pgp_principal_key (k);
 389   if (k->flags & KEYFLAG_CANTUSE)
 390     return 0;
 391   if (pk->flags & KEYFLAG_CANTUSE)
 392     return 0;
 393
 394   return 1;
 395 }
 396
 397 static int pgp_id_is_strong (pgp_uid_t *uid)
 398 {
 399   if ((uid->trust & 3) < 3)
 400     return 0;
 401   /* else */
 402   return 1;
 403 }
 404
 405 static int pgp_id_is_valid (pgp_uid_t *uid)
 406 {
 407   if (!pgp_key_is_valid (uid->parent))
 408     return 0;
 409   if (uid->flags & KEYFLAG_CANTUSE)
 410     return 0;
 411   /* else */
 412   return 1;
 413 }
 414
 415 #define PGP_KV_VALID    1
 416 #define PGP_KV_ADDR     2
 417 #define PGP_KV_STRING   4
 418 #define PGP_KV_STRONGID 8
 419
 420 #define PGP_KV_MATCH (PGP_KV_ADDR|PGP_KV_STRING)
 421
 422 static int pgp_id_matches_addr (ADDRESS *addr, ADDRESS *u_addr, pgp_uid_t *uid)
 423 {
 424   int rv = 0;
 425
 426   if (pgp_id_is_valid (uid))
 427     rv |= PGP_KV_VALID;
 428
 429   if (pgp_id_is_strong (uid))
 430     rv |= PGP_KV_STRONGID;
 431
 432   if (addr->mailbox && u_addr->mailbox
 433       && mutt_strcasecmp (addr->mailbox, u_addr->mailbox) == 0)
 434     rv |= PGP_KV_ADDR;
 435
 436   if (addr->personal && u_addr->personal
 437       && mutt_strcasecmp (addr->personal, u_addr->personal) == 0)
 438     rv |= PGP_KV_STRING;
 439
 440   return rv;
 441 }
 442
 443 static pgp_key_t pgp_select_key (pgp_key_t keys,
 444                                  ADDRESS * p, const char *s)
 445 {
 446   int keymax;
 447   pgp_uid_t **KeyTable;
 448   MUTTMENU *menu;
 449   int i, done = 0;
 450   char helpstr[LONG_STRING], buf[LONG_STRING], tmpbuf[STRING];
 451   char cmd[LONG_STRING], tempfile[_POSIX_PATH_MAX];
 452   FILE *fp, *devnull;
 453   pid_t thepid;
 454   pgp_key_t kp;
 455   pgp_uid_t *a;
 456   int (*f) (const void *, const void *);
 457
 458   int unusable = 0;
 459
 460   keymax = 0;
 461   KeyTable = NULL;
 462
 463   for (i = 0, kp = keys; kp; kp = kp->next)
 464   {
 465     if (!option (OPTPGPSHOWUNUSABLE) && (kp->flags & KEYFLAG_CANTUSE))
 466     {
 467       unusable = 1;
 468       continue;
 469     }
 470
 471     for (a = kp->address; a; a = a->next)
 472     {
 473       if (!option (OPTPGPSHOWUNUSABLE) && (a->flags & KEYFLAG_CANTUSE))
 474       {
 475         unusable = 1;
 476         continue;
 477       }
 478
 479       if (i == keymax)
 480       {
 481         keymax += 5;
 482         safe_realloc (&KeyTable, sizeof (pgp_uid_t *) * keymax);
 483       }
 484
 485       KeyTable[i++] = a;
 486     }
 487   }
 488
 489   if (!i && unusable)
 490   {
 491     mutt_error _("All matching keys are expired, revoked, or disabled.");
 492     mutt_sleep (1);
 493     return NULL;
 494   }
 495
 496   switch (PgpSortKeys & SORT_MASK)
 497   {
 498     case SORT_DATE:
 499       f = pgp_compare_date;
 500       break;
 501     case SORT_KEYID:
 502       f = pgp_compare_keyid;
 503       break;
 504     case SORT_ADDRESS:
 505       f = pgp_compare_address;
 506       break;
 507     case SORT_TRUST:
 508     default:
 509       f = pgp_compare_trust;
 510       break;
 511   }
 512   qsort (KeyTable, i, sizeof (pgp_uid_t *), f);
 513
 514   helpstr[0] = 0;
 515   mutt_make_help (buf, sizeof (buf), _("Exit  "), MENU_PGP, OP_EXIT);
 516   strcat (helpstr, buf);        /* __STRCAT_CHECKED__ */
 517   mutt_make_help (buf, sizeof (buf), _("Select  "), MENU_PGP,
 518                   OP_GENERIC_SELECT_ENTRY);
 519   strcat (helpstr, buf);        /* __STRCAT_CHECKED__ */
 520   mutt_make_help (buf, sizeof (buf), _("Check key  "), MENU_PGP, OP_VERIFY_KEY);
 521   strcat (helpstr, buf);        /* __STRCAT_CHECKED__ */
 522   mutt_make_help (buf, sizeof (buf), _("Help"), MENU_PGP, OP_HELP);
 523   strcat (helpstr, buf);        /* __STRCAT_CHECKED__ */
 524
 525   menu = mutt_new_menu (MENU_PGP);
 526   menu->max = i;
 527   menu->make_entry = pgp_entry;
 528   menu->help = helpstr;
 529   menu->data = KeyTable;
 530
 531   if (p)
 532     snprintf (buf, sizeof (buf), _("PGP keys matching <%s>."), p->mailbox);
 533   else
 534     snprintf (buf, sizeof (buf), _("PGP keys matching \"%s\"."), s);
 535
 536
 537   menu->title = buf;
 538
 539   kp = NULL;
 540
 541   mutt_clear_error ();
 542
 543   while (!done)
 544   {
 545     switch (mutt_menuLoop (menu))
 546     {
 547
 548     case OP_VERIFY_KEY:
 549
 550       mutt_mktemp (tempfile);
 551       if ((devnull = fopen ("/dev/null", "w")) == NULL) /* __FOPEN_CHECKED__ */
 552       {
 553         mutt_perror _("Can't open /dev/null");
 554         break;
 555       }
 556       if ((fp = safe_fopen (tempfile, "w")) == NULL)
 557       {
 558         safe_fclose (&devnull);
 559         mutt_perror _("Can't create temporary file");
 560         break;
 561       }
 562
 563       mutt_message _("Invoking PGP...");
 564
 565       snprintf (tmpbuf, sizeof (tmpbuf), "0x%s", pgp_keyid (pgp_principal_key (KeyTable[menu->current]->parent)));
 566
 567       if ((thepid = pgp_invoke_verify_key (NULL, NULL, NULL, -1,
 568                     fileno (fp), fileno (devnull), tmpbuf)) == -1)
 569       {
 570         mutt_perror _("Can't create filter");
 571         unlink (tempfile);
 572         safe_fclose (&fp);
 573         safe_fclose (&devnull);
 574       }
 575
 576       mutt_wait_filter (thepid);
 577       safe_fclose (&fp);
 578       safe_fclose (&devnull);
 579       mutt_clear_error ();
 580       snprintf (cmd, sizeof (cmd), _("Key ID: 0x%s"),
 581                 pgp_keyid (pgp_principal_key (KeyTable[menu->current]->parent)));
 582       mutt_do_pager (cmd, tempfile, 0, NULL);
 583       menu->redraw = REDRAW_FULL;
 584
 585       break;
 586
 587     case OP_VIEW_ID:
 588
 589       mutt_message ("%s", KeyTable[menu->current]->addr);
 590       break;
 591
 592     case OP_GENERIC_SELECT_ENTRY:
 593
 594
 595       /* XXX make error reporting more verbose */
 596
 597       if (option (OPTPGPCHECKTRUST))
 598         if (!pgp_key_is_valid (KeyTable[menu->current]->parent))
 599         {
 600           mutt_error _("This key can't be used: expired/disabled/revoked.");
 601           break;
 602         }
 603
 604       if (option (OPTPGPCHECKTRUST) &&
 605           (!pgp_id_is_valid (KeyTable[menu->current])
 606            || !pgp_id_is_strong (KeyTable[menu->current])))
 607       {
 608         char *s = "";
 609         char buff[LONG_STRING];
 610
 611         if (KeyTable[menu->current]->flags & KEYFLAG_CANTUSE)
 612           s = N_("ID is expired/disabled/revoked.");
 613         else switch (KeyTable[menu->current]->trust & 0x03)
 614         {
 615           case 0:
 616             s = N_("ID has undefined validity.");
 617             break;
 618           case 1:
 619             s = N_("ID is not valid.");
 620             break;
 621           case 2:
 622             s = N_("ID is only marginally valid.");
 623             break;
 624         }
 625
 626         snprintf (buff, sizeof (buff), _("%s Do you really want to use the key?"),
 627                   _(s));
 628
 629         if (mutt_yesorno (buff, M_NO) != M_YES)
 630         {
 631           mutt_clear_error ();
 632           break;
 633         }
 634       }
 635
 636 # if 0
 637       kp = pgp_principal_key (KeyTable[menu->current]->parent);
 638 # else
 639       kp = KeyTable[menu->current]->parent;
 640 # endif
 641       done = 1;
 642       break;
 643
 644     case OP_EXIT:
 645
 646       kp = NULL;
 647       done = 1;
 648       break;
 649     }
 650   }
 651
 652   mutt_menuDestroy (&menu);
 653   FREE (&KeyTable);
 654
 655   set_option (OPTNEEDREDRAW);
 656
 657   return (kp);
 658 }
 659
 660 pgp_key_t pgp_ask_for_key (char *tag, char *whatfor,
 661                            short abilities, pgp_ring_t keyring)
 662 {
 663   pgp_key_t key;
 664   char resp[SHORT_STRING];
 665   struct pgp_cache *l = NULL;
 666
 667   mutt_clear_error ();
 668
 669   resp[0] = 0;
 670   if (whatfor)
 671   {
 672
 673     for (l = id_defaults; l; l = l->next)
 674       if (!mutt_strcasecmp (whatfor, l->what))
 675       {
 676         strfcpy (resp, NONULL (l->dflt), sizeof (resp));
 677         break;
 678       }
 679   }
 680
 681
 682   FOREVER
 683   {
 684     resp[0] = 0;
 685     if (mutt_get_field (tag, resp, sizeof (resp), M_CLEAR) != 0)
 686       return NULL;
 687
 688     if (whatfor)
 689     {
 690       if (l)
 691         mutt_str_replace (&l->dflt, resp);
 692       else
 693       {
 694         l = safe_malloc (sizeof (struct pgp_cache));
 695         l->next = id_defaults;
 696         id_defaults = l;
 697         l->what = safe_strdup (whatfor);
 698         l->dflt = safe_strdup (resp);
 699       }
 700     }
 701
 702     if ((key = pgp_getkeybystr (resp, abilities, keyring)))
 703       return key;
 704
 705     BEEP ();
 706   }
 707   /* not reached */
 708 }
 709
 710 /* generate a public key attachment */
 711
 712 BODY *pgp_make_key_attachment (char *tempf)
 713 {
 714   BODY *att;
 715   char buff[LONG_STRING];
 716   char tempfb[_POSIX_PATH_MAX], tmp[STRING];
 717   FILE *tempfp;
 718   FILE *devnull;
 719   struct stat sb;
 720   pid_t thepid;
 721   pgp_key_t key;
 722   unset_option (OPTPGPCHECKTRUST);
 723
 724   key = pgp_ask_for_key (_("Please enter the key ID: "), NULL, 0, PGP_PUBRING);
 725
 726   if (!key)    return NULL;
 727
 728   snprintf (tmp, sizeof (tmp), "0x%s", pgp_keyid (pgp_principal_key (key)));
 729   pgp_free_key (&key);
 730
 731   if (!tempf)
 732   {
 733     mutt_mktemp (tempfb);
 734     tempf = tempfb;
 735   }
 736
 737   if ((tempfp = safe_fopen (tempf, tempf == tempfb ? "w" : "a")) == NULL)
 738   {
 739     mutt_perror _("Can't create temporary file");
 740     return NULL;
 741   }
 742
 743   if ((devnull = fopen ("/dev/null", "w")) == NULL)     /* __FOPEN_CHECKED__ */
 744   {
 745     mutt_perror _("Can't open /dev/null");
 746     safe_fclose (&tempfp);
 747     if (tempf == tempfb)
 748       unlink (tempf);
 749     return NULL;
 750   }
 751
 752   mutt_message _("Invoking PGP...");
 753
 754
 755   if ((thepid =
 756        pgp_invoke_export (NULL, NULL, NULL, -1,
 757                            fileno (tempfp), fileno (devnull), tmp)) == -1)
 758   {
 759     mutt_perror _("Can't create filter");
 760     unlink (tempf);
 761     safe_fclose (&tempfp);
 762     safe_fclose (&devnull);
 763     return NULL;
 764   }
 765
 766   mutt_wait_filter (thepid);
 767
 768   safe_fclose (&tempfp);
 769   safe_fclose (&devnull);
 770
 771   att = mutt_new_body ();
 772   att->filename = safe_strdup (tempf);
 773   att->unlink = 1;
 774   att->use_disp = 0;
 775   att->type = TYPEAPPLICATION;
 776   att->subtype = safe_strdup ("pgp-keys");
 777   snprintf (buff, sizeof (buff), _("PGP Key %s."), tmp);
 778   att->description = safe_strdup (buff);
 779   mutt_update_encoding (att);
 780
 781   stat (tempf, &sb);
 782   att->length = sb.st_size;
 783
 784   return att;
 785 }
 786
 787 static LIST *pgp_add_string_to_hints (LIST *hints, const char *str)
 788 {
 789   char *scratch;
 790   char *t;
 791
 792   if ((scratch = safe_strdup (str)) == NULL)
 793     return hints;
 794
 795   for (t = strtok (scratch, " ,.:\"()<>\n"); t;
 796                 t = strtok (NULL, " ,.:\"()<>\n"))
 797   {
 798     if (strlen (t) > 3)
 799       hints = mutt_add_list (hints, t);
 800   }
 801
 802   FREE (&scratch);
 803   return hints;
 804 }
 805
 806 static pgp_key_t *pgp_get_lastp (pgp_key_t p)
 807 {
 808   for (; p; p = p->next)
 809     if (!p->next)
 810       return &p->next;
 811
 812   return NULL;
 813 }
 814
 815 pgp_key_t pgp_getkeybyaddr (ADDRESS * a, short abilities, pgp_ring_t keyring)
 816 {
 817   ADDRESS *r, *p;
 818   LIST *hints = NULL;
 819
 820   int multi   = 0;
 821   int match;
 822
 823   pgp_key_t keys, k, kn;
 824   pgp_key_t the_valid_key = NULL;
 825   pgp_key_t matches = NULL;
 826   pgp_key_t *last = &matches;
 827   pgp_uid_t *q;
 828
 829   if (a && a->mailbox)
 830     hints = pgp_add_string_to_hints (hints, a->mailbox);
 831   if (a && a->personal)
 832     hints = pgp_add_string_to_hints (hints, a->personal);
 833
 834   mutt_message (_("Looking for keys matching \"%s\"..."), a->mailbox);
 835   keys = pgp_get_candidates (keyring, hints);
 836
 837   mutt_free_list (&hints);
 838
 839   if (!keys)
 840     return NULL;
 841
 842   dprint (5, (debugfile, "pgp_getkeybyaddr: looking for %s <%s>.",
 843               a->personal, a->mailbox));
 844
 845
 846   for (k = keys; k; k = kn)
 847   {
 848     kn = k->next;
 849
 850     dprint (5, (debugfile, "  looking at key: %s\n",
 851                 pgp_keyid (k)));
 852
 853     if (abilities && !(k->flags & abilities))
 854     {
 855       dprint (5, (debugfile, "  insufficient abilities: Has %x, want %x\n",
 856                   k->flags, abilities));
 857       continue;
 858     }
 859
 860     match                = 0;   /* any match              */
 861
 862     for (q = k->address; q; q = q->next)
 863     {
 864       r = rfc822_parse_adrlist (NULL, q->addr);
 865
 866       for (p = r; p; p = p->next)
 867       {
 868         int validity = pgp_id_matches_addr (a, p, q);
 869
 870         if (validity & PGP_KV_MATCH)    /* something matches */
 871           match = 1;
 872
 873         /* is this key a strong candidate? */
 874         if ((validity & PGP_KV_VALID) && (validity & PGP_KV_STRONGID)
 875             && (validity & PGP_KV_ADDR))
 876         {
 877           if (the_valid_key && the_valid_key != k)
 878             multi             = 1;
 879           the_valid_key       = k;
 880         }
 881       }
 882
 883       rfc822_free_address (&r);
 884     }
 885
 886     if (match)
 887     {
 888       *last  = pgp_principal_key (k);
 889       kn     = pgp_remove_key (&keys, *last);
 890       last   = pgp_get_lastp (k);
 891     }
 892   }
 893
 894   pgp_free_key (&keys);
 895
 896   if (matches)
 897   {
 898     if (the_valid_key && !multi)
 899     {
 900       /*
 901        * There was precisely one strong match on a valid ID.
 902        *
 903        * Proceed without asking the user.
 904        */
 905       pgp_remove_key (&matches, the_valid_key);
 906       pgp_free_key (&matches);
 907       k = the_valid_key;
 908     }
 909     else
 910     {
 911       /*
 912        * Else: Ask the user.
 913        */
 914       if ((k = pgp_select_key (matches, a, NULL)))
 915         pgp_remove_key (&matches, k);
 916       pgp_free_key (&matches);
 917     }
 918
 919     return k;
 920   }
 921
 922   return NULL;
 923 }
 924
 925 pgp_key_t pgp_getkeybystr (char *p, short abilities, pgp_ring_t keyring)
 926 {
 927   LIST *hints = NULL;
 928   pgp_key_t keys;
 929   pgp_key_t matches = NULL;
 930   pgp_key_t *last = &matches;
 931   pgp_key_t k, kn;
 932   pgp_uid_t *a;
 933   short match;
 934   size_t l;
 935
 936   if ((l = mutt_strlen (p)) && p[l-1] == '!')
 937     p[l-1] = 0;
 938
 939   mutt_message (_("Looking for keys matching \"%s\"..."), p);
 940
 941   hints = pgp_add_string_to_hints (hints, p);
 942   keys = pgp_get_candidates (keyring, hints);
 943   mutt_free_list (&hints);
 944
 945   if (!keys)
 946     goto out;
 947
 948   for (k = keys; k; k = kn)
 949   {
 950     kn = k->next;
 951     if (abilities && !(k->flags & abilities))
 952       continue;
 953
 954     match = 0;
 955
 956     for (a = k->address; a; a = a->next)
 957     {
 958       dprint (5, (debugfile, "pgp_getkeybystr: matching \"%s\" against key %s, \"%s\": ",
 959                   p, pgp_keyid (k), a->addr));
 960       if (!*p || mutt_strcasecmp (p, pgp_keyid (k)) == 0 ||
 961           (!mutt_strncasecmp (p, "0x", 2) && !mutt_strcasecmp (p + 2, pgp_keyid (k))) ||
 962           (option (OPTPGPLONGIDS) && !mutt_strncasecmp (p, "0x", 2) &&
 963            !mutt_strcasecmp (p + 2, k->keyid + 8)) ||
 964           mutt_stristr (a->addr, p))
 965       {
 966         dprint (5, (debugfile, "match.\n"));
 967         match = 1;
 968         break;
 969       }
 970     }
 971
 972     if (match)
 973     {
 974       *last = pgp_principal_key (k);
 975       kn    = pgp_remove_key (&keys, *last);
 976       last  = pgp_get_lastp (k);
 977     }
 978   }
 979
 980   pgp_free_key (&keys);
 981
 982   if (matches)
 983   {
 984     if ((k = pgp_select_key (matches, NULL, p)))
 985       pgp_remove_key (&matches, k);
 986
 987     pgp_free_key (&matches);
 988     if (!p[l-1])
 989       p[l-1] = '!';
 990     return k;
 991   }
 992
 993 out:
 994   if (!p[l-1])
 995     p[l-1] = '!';
 996   return NULL;
 997 }
 998
 999 #endif /* CRYPT_BACKEND_CLASSIC_PGP */