g10/pkclist.c

   1 /* pkclist.c - create a list of public keys
   2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
   3  *               2008, 2009, 2010 Free Software Foundation, Inc.
   4  *
   5  * This file is part of GnuPG.
   6  *
   7  * GnuPG is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 3 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * GnuPG is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <config.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <errno.h>
  26 #include <assert.h>
  27
  28 #include "gpg.h"
  29 #include "options.h"
  30 #include "packet.h"
  31 #include "status.h"
  32 #include "keydb.h"
  33 #include "util.h"
  34 #include "main.h"
  35 #include "trustdb.h"
  36 #include "ttyio.h"
  37 #include "status.h"
  38 #include "photoid.h"
  39 #include "i18n.h"
  40
  41 #define CONTROL_D ('D' - 'A' + 1)
  42
  43 static void
  44 send_status_inv_recp (int reason, const char *name)
  45 {
  46   char buf[40];
  47
  48   snprintf (buf, sizeof buf, "%d ", reason);
  49   write_status_text_and_buffer (STATUS_INV_RECP, buf,
  50                                 name, strlen (name),
  51                                 -1);
  52 }
  53
  54
  55 /****************
  56  * Show the revocation reason as it is stored with the given signature
  57  */
  58 static void
  59 do_show_revocation_reason( PKT_signature *sig )
  60 {
  61     size_t n, nn;
  62     const byte *p, *pp;
  63     int seq = 0;
  64     const char *text;
  65
  66     while( (p = enum_sig_subpkt (sig->hashed, SIGSUBPKT_REVOC_REASON,
  67                                  &n, &seq, NULL )) ) {
  68         if( !n )
  69             continue; /* invalid - just skip it */
  70
  71         if( *p == 0 )
  72             text = _("No reason specified");
  73         else if( *p == 0x01 )
  74             text = _("Key is superseded");
  75         else if( *p == 0x02 )
  76             text = _("Key has been compromised");
  77         else if( *p == 0x03 )
  78             text = _("Key is no longer used");
  79         else if( *p == 0x20 )
  80             text = _("User ID is no longer valid");
  81         else
  82             text = NULL;
  83
  84         log_info ( _("reason for revocation: "));
  85         if (text)
  86           log_printf ("%s\n", text);
  87         else
  88           log_printf ("code=%02x\n", *p );
  89         n--; p++;
  90         pp = NULL;
  91         do {
  92             /* We don't want any empty lines, so skip them */
  93             while( n && *p == '\n' ) {
  94                 p++;
  95                 n--;
  96             }
  97             if( n ) {
  98                 pp = memchr( p, '\n', n );
  99                 nn = pp? pp - p : n;
 100                 log_info ( _("revocation comment: ") );
 101                 es_write_sanitized (log_get_stream(), p, nn, NULL, NULL);
 102                 log_printf ("\n");
 103                 p += nn; n -= nn;
 104             }
 105         } while( pp );
 106     }
 107 }
 108
 109 /* Mode 0: try and find the revocation based on the pk (i.e. check
 110    subkeys, etc.)  Mode 1: use only the revocation on the main pk */
 111
 112 void
 113 show_revocation_reason( PKT_public_key *pk, int mode )
 114 {
 115     /* Hmmm, this is not so easy becuase we have to duplicate the code
 116      * used in the trustbd to calculate the keyflags.  We need to find
 117      * a clean way to check revocation certificates on keys and
 118      * signatures.  And there should be no duplicate code.  Because we
 119      * enter this function only when the trustdb told us that we have
 120      * a revoked key, we could simply look for a revocation cert and
 121      * display this one, when there is only one. Let's try to do this
 122      * until we have a better solution.  */
 123     KBNODE node, keyblock = NULL;
 124     byte fingerprint[MAX_FINGERPRINT_LEN];
 125     size_t fingerlen;
 126     int rc;
 127
 128     /* get the keyblock */
 129     fingerprint_from_pk( pk, fingerprint, &fingerlen );
 130     rc = get_keyblock_byfprint( &keyblock, fingerprint, fingerlen );
 131     if( rc ) { /* that should never happen */
 132         log_debug( "failed to get the keyblock\n");
 133         return;
 134     }
 135
 136     for( node=keyblock; node; node = node->next ) {
 137         if( (mode && node->pkt->pkttype == PKT_PUBLIC_KEY) ||
 138           ( ( node->pkt->pkttype == PKT_PUBLIC_KEY
 139               || node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
 140             && !cmp_public_keys( node->pkt->pkt.public_key, pk ) ) )
 141             break;
 142     }
 143     if( !node ) {
 144         log_debug("Oops, PK not in keyblock\n");
 145         release_kbnode( keyblock );
 146         return;
 147     }
 148     /* now find the revocation certificate */
 149     for( node = node->next; node ; node = node->next ) {
 150         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
 151             break;
 152         if( node->pkt->pkttype == PKT_SIGNATURE
 153             && (node->pkt->pkt.signature->sig_class == 0x20
 154                 || node->pkt->pkt.signature->sig_class == 0x28 ) ) {
 155                 /* FIXME: we should check the signature here */
 156                 do_show_revocation_reason ( node->pkt->pkt.signature );
 157                 break;
 158         }
 159     }
 160
 161     /* We didn't find it, so check if the whole key is revoked */
 162     if(!node && !mode)
 163       show_revocation_reason(pk,1);
 164
 165     release_kbnode( keyblock );
 166 }
 167
 168
 169 /****************
 170  * mode: 0 = standard
 171  *       1 = Without key info and additional menu option 'm'
 172  *           this does also add an option to set the key to ultimately trusted.
 173  * Returns:
 174  *      -2 = nothing changed - caller should show some additional info
 175  *      -1 = quit operation
 176  *       0 = nothing changed
 177  *       1 = new ownertrust now in new_trust
 178  */
 179 #ifndef NO_TRUST_MODELS
 180 static int
 181 do_edit_ownertrust (PKT_public_key *pk, int mode,
 182                     unsigned *new_trust, int defer_help )
 183 {
 184   char *p;
 185   u32 keyid[2];
 186   int changed=0;
 187   int quit=0;
 188   int show=0;
 189   int min_num;
 190   int did_help=defer_help;
 191   unsigned int minimum = tdb_get_min_ownertrust (pk);
 192   char pkstrbuf[PUBKEY_STRING_SIZE];
 193
 194   switch(minimum)
 195     {
 196     default:
 197     case TRUST_UNDEFINED: min_num=1; break;
 198     case TRUST_NEVER:     min_num=2; break;
 199     case TRUST_MARGINAL:  min_num=3; break;
 200     case TRUST_FULLY:     min_num=4; break;
 201     }
 202
 203   keyid_from_pk (pk, keyid);
 204   for(;;) {
 205     /* A string with valid answers.
 206
 207        TRANSLATORS: These are the allowed answers in lower and
 208        uppercase.  Below you will find the matching strings which
 209        should be translated accordingly and the letter changed to
 210        match the one in the answer string.
 211
 212          i = please show me more information
 213          m = back to the main menu
 214          s = skip this key
 215          q = quit
 216     */
 217     const char *ans = _("iImMqQsS");
 218
 219     if( !did_help )
 220       {
 221         if( !mode )
 222           {
 223             KBNODE keyblock, un;
 224
 225             tty_printf(_("No trust value assigned to:\n"));
 226             tty_printf("%s/%s %s\n",
 227                        pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
 228                        keystr(keyid), datestr_from_pk( pk ) );
 229             p=get_user_id_native(keyid);
 230             tty_printf(_("      \"%s\"\n"),p);
 231             xfree(p);
 232
 233             keyblock = get_pubkeyblock (keyid);
 234             if (!keyblock)
 235                 BUG ();
 236             for (un=keyblock; un; un = un->next)
 237               {
 238                 if (un->pkt->pkttype != PKT_USER_ID )
 239                   continue;
 240                 if (un->pkt->pkt.user_id->is_revoked )
 241                   continue;
 242                 if (un->pkt->pkt.user_id->is_expired )
 243                   continue;
 244                 /* Only skip textual primaries */
 245                 if (un->pkt->pkt.user_id->is_primary
 246                     && !un->pkt->pkt.user_id->attrib_data )
 247                   continue;
 248
 249                 if((opt.verify_options&VERIFY_SHOW_PHOTOS)
 250                    && un->pkt->pkt.user_id->attrib_data)
 251                   show_photos (un->pkt->pkt.user_id->attribs,
 252                                un->pkt->pkt.user_id->numattribs, pk,
 253                                un->pkt->pkt.user_id);
 254
 255                 p=utf8_to_native(un->pkt->pkt.user_id->name,
 256                                  un->pkt->pkt.user_id->len,0);
 257
 258                 tty_printf(_("  aka \"%s\"\n"),p);
 259               }
 260
 261             print_fingerprint (NULL, pk, 2);
 262             tty_printf("\n");
 263             release_kbnode (keyblock);
 264           }
 265
 266         if(opt.trust_model==TM_DIRECT)
 267           {
 268             tty_printf(_("How much do you trust that this key actually "
 269                          "belongs to the named user?\n"));
 270             tty_printf("\n");
 271           }
 272         else
 273           {
 274             /* This string also used in keyedit.c:trustsig_prompt */
 275             tty_printf(_("Please decide how far you trust this user to"
 276                          " correctly verify other users' keys\n"
 277                          "(by looking at passports, checking fingerprints from"
 278                          " different sources, etc.)\n"));
 279             tty_printf("\n");
 280           }
 281
 282         if(min_num<=1)
 283           tty_printf (_("  %d = I don't know or won't say\n"), 1);
 284         if(min_num<=2)
 285           tty_printf (_("  %d = I do NOT trust\n"), 2);
 286         if(min_num<=3)
 287           tty_printf (_("  %d = I trust marginally\n"), 3);
 288         if(min_num<=4)
 289           tty_printf (_("  %d = I trust fully\n"), 4);
 290         if (mode)
 291           tty_printf (_("  %d = I trust ultimately\n"), 5);
 292 #if 0
 293         /* not yet implemented */
 294         tty_printf ("  i = please show me more information\n");
 295 #endif
 296         if( mode )
 297           tty_printf(_("  m = back to the main menu\n"));
 298         else
 299           {
 300             tty_printf(_("  s = skip this key\n"));
 301             tty_printf(_("  q = quit\n"));
 302           }
 303         tty_printf("\n");
 304         if(minimum)
 305           tty_printf(_("The minimum trust level for this key is: %s\n\n"),
 306                      trust_value_to_string(minimum));
 307         did_help = 1;
 308       }
 309     if( strlen(ans) != 8 )
 310       BUG();
 311     p = cpr_get("edit_ownertrust.value",_("Your decision? "));
 312     trim_spaces(p);
 313     cpr_kill_prompt();
 314     if( !*p )
 315       did_help = 0;
 316     else if( *p && p[1] )
 317       ;
 318     else if( !p[1] && ((*p >= '0'+min_num) && *p <= (mode?'5':'4')) )
 319       {
 320         unsigned int trust;
 321         switch( *p )
 322           {
 323           case '1': trust = TRUST_UNDEFINED; break;
 324           case '2': trust = TRUST_NEVER    ; break;
 325           case '3': trust = TRUST_MARGINAL ; break;
 326           case '4': trust = TRUST_FULLY    ; break;
 327           case '5': trust = TRUST_ULTIMATE ; break;
 328           default: BUG();
 329           }
 330         if (trust == TRUST_ULTIMATE
 331             && !cpr_get_answer_is_yes ("edit_ownertrust.set_ultimate.okay",
 332                                        _("Do you really want to set this key"
 333                                          " to ultimate trust? (y/N) ")))
 334           ; /* no */
 335         else
 336           {
 337             *new_trust = trust;
 338             changed = 1;
 339             break;
 340           }
 341       }
 342 #if 0
 343     /* not yet implemented */
 344     else if( *p == ans[0] || *p == ans[1] )
 345       {
 346         tty_printf(_("Certificates leading to an ultimately trusted key:\n"));
 347         show = 1;
 348         break;
 349       }
 350 #endif
 351     else if( mode && (*p == ans[2] || *p == ans[3] || *p == CONTROL_D ) )
 352       {
 353         break ; /* back to the menu */
 354       }
 355     else if( !mode && (*p == ans[6] || *p == ans[7] ) )
 356       {
 357         break; /* skip */
 358       }
 359     else if( !mode && (*p == ans[4] || *p == ans[5] ) )
 360       {
 361         quit = 1;
 362         break ; /* back to the menu */
 363       }
 364     xfree(p); p = NULL;
 365   }
 366   xfree(p);
 367   return show? -2: quit? -1 : changed;
 368 }
 369 #endif /*!NO_TRUST_MODELS*/
 370
 371
 372 /*
 373  * Display a menu to change the ownertrust of the key PK (which should
 374  * be a primary key).
 375  * For mode values see do_edit_ownertrust ()
 376  */
 377 #ifndef NO_TRUST_MODELS
 378 int
 379 edit_ownertrust (PKT_public_key *pk, int mode )
 380 {
 381   unsigned int trust = 0;
 382   int no_help = 0;
 383
 384   for(;;)
 385     {
 386       switch ( do_edit_ownertrust (pk, mode, &trust, no_help ) )
 387         {
 388         case -1: /* quit */
 389           return -1;
 390         case -2: /* show info */
 391           no_help = 1;
 392           break;
 393         case 1: /* trust value set */
 394           trust &= ~TRUST_FLAG_DISABLED;
 395           trust |= get_ownertrust (pk) & TRUST_FLAG_DISABLED;
 396           update_ownertrust (pk, trust );
 397           return 1;
 398         default:
 399           return 0;
 400         }
 401     }
 402 }
 403 #endif /*!NO_TRUST_MODELS*/
 404
 405
 406 /****************
 407  * Check whether we can trust this pk which has a trustlevel of TRUSTLEVEL
 408  * Returns: true if we trust.
 409  */
 410 static int
 411 do_we_trust( PKT_public_key *pk, unsigned int trustlevel )
 412 {
 413   /* We should not be able to get here with a revoked or expired
 414      key */
 415   if(trustlevel & TRUST_FLAG_REVOKED
 416      || trustlevel & TRUST_FLAG_SUB_REVOKED
 417      || (trustlevel & TRUST_MASK) == TRUST_EXPIRED)
 418     BUG();
 419
 420   if( opt.trust_model==TM_ALWAYS )
 421     {
 422       if( opt.verbose )
 423         log_info("No trust check due to '--trust-model always' option\n");
 424       return 1;
 425     }
 426
 427   switch(trustlevel & TRUST_MASK)
 428     {
 429     default:
 430       log_error ("invalid trustlevel %u returned from validation layer\n",
 431                  trustlevel);
 432       /* fall thru */
 433     case TRUST_UNKNOWN:
 434     case TRUST_UNDEFINED:
 435       log_info(_("%s: There is no assurance this key belongs"
 436                  " to the named user\n"),keystr_from_pk(pk));
 437       return 0; /* no */
 438
 439     case TRUST_MARGINAL:
 440       log_info(_("%s: There is limited assurance this key belongs"
 441                  " to the named user\n"),keystr_from_pk(pk));
 442       return 1; /* yes */
 443
 444     case TRUST_FULLY:
 445       if( opt.verbose )
 446         log_info(_("This key probably belongs to the named user\n"));
 447       return 1; /* yes */
 448
 449     case TRUST_ULTIMATE:
 450       if( opt.verbose )
 451         log_info(_("This key belongs to us\n"));
 452       return 1; /* yes */
 453     }
 454
 455   return 1; /*NOTREACHED*/
 456 }
 457
 458
 459 /****************
 460  * wrapper around do_we_trust, so we can ask whether to use the
 461  * key anyway.
 462  */
 463 static int
 464 do_we_trust_pre( PKT_public_key *pk, unsigned int trustlevel )
 465 {
 466   int rc;
 467
 468   rc = do_we_trust( pk, trustlevel );
 469
 470   if( !opt.batch && !rc )
 471     {
 472       print_pubkey_info(NULL,pk);
 473       print_fingerprint (NULL, pk, 2);
 474       tty_printf("\n");
 475
 476       tty_printf(
 477                _("It is NOT certain that the key belongs to the person named\n"
 478                  "in the user ID.  If you *really* know what you are doing,\n"
 479                  "you may answer the next question with yes.\n"));
 480
 481       tty_printf("\n");
 482
 483
 484       if (is_status_enabled ())
 485         {
 486           u32 kid[2];
 487           char *hint_str;
 488
 489           keyid_from_pk (pk, kid);
 490           hint_str = get_long_user_id_string ( kid );
 491           write_status_text ( STATUS_USERID_HINT, hint_str );
 492           xfree (hint_str);
 493         }
 494
 495       if( cpr_get_answer_is_yes("untrusted_key.override",
 496                                 _("Use this key anyway? (y/N) "))  )
 497         rc = 1;
 498
 499       /* Hmmm: Should we set a flag to tell the user about
 500        *         his decision the next time he encrypts for this recipient?
 501        */
 502     }
 503
 504   return rc;
 505 }
 506
 507
 508 /****************
 509  * Check whether we can trust this signature.
 510  * Returns: Error if we shall not trust this signatures.
 511  */
 512 int
 513 check_signatures_trust( PKT_signature *sig )
 514 {
 515   PKT_public_key *pk = xmalloc_clear( sizeof *pk );
 516   unsigned int trustlevel;
 517   int rc=0;
 518
 519   rc = get_pubkey( pk, sig->keyid );
 520   if (rc)
 521     { /* this should not happen */
 522       log_error("Ooops; the key vanished  - can't check the trust\n");
 523       rc = GPG_ERR_NO_PUBKEY;
 524       goto leave;
 525     }
 526
 527   if ( opt.trust_model==TM_ALWAYS )
 528     {
 529       if( !opt.quiet )
 530         log_info(_("WARNING: Using untrusted key!\n"));
 531       if (opt.with_fingerprint)
 532         print_fingerprint (NULL, pk, 1);
 533       goto leave;
 534     }
 535
 536   if(pk->flags.maybe_revoked && !pk->flags.revoked)
 537     log_info(_("WARNING: this key might be revoked (revocation key"
 538                " not present)\n"));
 539
 540   trustlevel = get_validity (pk, NULL);
 541
 542   if ( (trustlevel & TRUST_FLAG_REVOKED) )
 543     {
 544       write_status( STATUS_KEYREVOKED );
 545       if(pk->flags.revoked == 2)
 546         log_info(_("WARNING: This key has been revoked by its"
 547                    " designated revoker!\n"));
 548       else
 549         log_info(_("WARNING: This key has been revoked by its owner!\n"));
 550       log_info(_("         This could mean that the signature is forged.\n"));
 551       show_revocation_reason( pk, 0 );
 552     }
 553   else if ((trustlevel & TRUST_FLAG_SUB_REVOKED) )
 554     {
 555       write_status( STATUS_KEYREVOKED );
 556       log_info(_("WARNING: This subkey has been revoked by its owner!\n"));
 557       show_revocation_reason( pk, 0 );
 558     }
 559
 560   if ((trustlevel & TRUST_FLAG_DISABLED))
 561     log_info (_("Note: This key has been disabled.\n"));
 562
 563   /* If we have PKA information adjust the trustlevel. */
 564   if (sig->pka_info && sig->pka_info->valid)
 565     {
 566       unsigned char fpr[MAX_FINGERPRINT_LEN];
 567       PKT_public_key *primary_pk;
 568       size_t fprlen;
 569       int okay;
 570
 571
 572       primary_pk = xmalloc_clear (sizeof *primary_pk);
 573       get_pubkey (primary_pk, pk->main_keyid);
 574       fingerprint_from_pk (primary_pk, fpr, &fprlen);
 575       free_public_key (primary_pk);
 576
 577       if ( fprlen == 20 && !memcmp (sig->pka_info->fpr, fpr, 20) )
 578         {
 579           okay = 1;
 580           write_status_text (STATUS_PKA_TRUST_GOOD, sig->pka_info->email);
 581           log_info (_("Note: Verified signer's address is '%s'\n"),
 582                     sig->pka_info->email);
 583         }
 584       else
 585         {
 586           okay = 0;
 587           write_status_text (STATUS_PKA_TRUST_BAD, sig->pka_info->email);
 588           log_info (_("Note: Signer's address '%s' "
 589                       "does not match DNS entry\n"), sig->pka_info->email);
 590         }
 591
 592       switch ( (trustlevel & TRUST_MASK) )
 593         {
 594         case TRUST_UNKNOWN:
 595         case TRUST_UNDEFINED:
 596         case TRUST_MARGINAL:
 597           if (okay && opt.verify_options&VERIFY_PKA_TRUST_INCREASE)
 598             {
 599               trustlevel = ((trustlevel & ~TRUST_MASK) | TRUST_FULLY);
 600               log_info (_("trustlevel adjusted to FULL"
 601                           " due to valid PKA info\n"));
 602             }
 603           /* (fall through) */
 604         case TRUST_FULLY:
 605           if (!okay)
 606             {
 607               trustlevel = ((trustlevel & ~TRUST_MASK) | TRUST_NEVER);
 608               log_info (_("trustlevel adjusted to NEVER"
 609                           " due to bad PKA info\n"));
 610             }
 611           break;
 612         }
 613     }
 614
 615   /* Now let the user know what up with the trustlevel. */
 616   switch ( (trustlevel & TRUST_MASK) )
 617     {
 618     case TRUST_EXPIRED:
 619       log_info(_("Note: This key has expired!\n"));
 620       print_fingerprint (NULL, pk, 1);
 621       break;
 622
 623     default:
 624       log_error ("invalid trustlevel %u returned from validation layer\n",
 625                  trustlevel);
 626       /* fall thru */
 627     case TRUST_UNKNOWN:
 628     case TRUST_UNDEFINED:
 629       write_status( STATUS_TRUST_UNDEFINED );
 630       log_info(_("WARNING: This key is not certified with"
 631                  " a trusted signature!\n"));
 632       log_info(_("         There is no indication that the "
 633                  "signature belongs to the owner.\n" ));
 634       print_fingerprint (NULL, pk, 1);
 635       break;
 636
 637     case TRUST_NEVER:
 638       /* currently we won't get that status */
 639       write_status( STATUS_TRUST_NEVER );
 640       log_info(_("WARNING: We do NOT trust this key!\n"));
 641       log_info(_("         The signature is probably a FORGERY.\n"));
 642       if (opt.with_fingerprint)
 643         print_fingerprint (NULL, pk, 1);
 644       rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
 645       break;
 646
 647     case TRUST_MARGINAL:
 648       write_status( STATUS_TRUST_MARGINAL );
 649       log_info(_("WARNING: This key is not certified with"
 650                  " sufficiently trusted signatures!\n"));
 651       log_info(_("         It is not certain that the"
 652                  " signature belongs to the owner.\n" ));
 653       print_fingerprint (NULL, pk, 1);
 654       break;
 655
 656     case TRUST_FULLY:
 657       write_status( STATUS_TRUST_FULLY );
 658       if (opt.with_fingerprint)
 659         print_fingerprint (NULL, pk, 1);
 660       break;
 661
 662     case TRUST_ULTIMATE:
 663       write_status( STATUS_TRUST_ULTIMATE );
 664       if (opt.with_fingerprint)
 665         print_fingerprint (NULL, pk, 1);
 666       break;
 667     }
 668
 669  leave:
 670   free_public_key( pk );
 671   return rc;
 672 }
 673
 674
 675 void
 676 release_pk_list (pk_list_t pk_list)
 677 {
 678   PK_LIST pk_rover;
 679
 680   for ( ; pk_list; pk_list = pk_rover)
 681     {
 682       pk_rover = pk_list->next;
 683       free_public_key ( pk_list->pk );
 684       xfree ( pk_list );
 685     }
 686 }
 687
 688
 689 static int
 690 key_present_in_pk_list(PK_LIST pk_list, PKT_public_key *pk)
 691 {
 692     for( ; pk_list; pk_list = pk_list->next)
 693         if (cmp_public_keys(pk_list->pk, pk) == 0)
 694             return 0;
 695
 696     return -1;
 697 }
 698
 699
 700 /****************
 701  * Return a malloced string with a default recipient if there is any
 702  */
 703 static char *
 704 default_recipient(void)
 705 {
 706     PKT_public_key *pk;
 707     byte fpr[MAX_FINGERPRINT_LEN+1];
 708     size_t n;
 709     char *p;
 710     int i;
 711
 712     if( opt.def_recipient )
 713         return xstrdup( opt.def_recipient );
 714     if( !opt.def_recipient_self )
 715         return NULL;
 716     pk = xmalloc_clear( sizeof *pk );
 717     i = get_seckey_byname (pk, NULL);
 718     if( i ) {
 719         free_public_key( pk );
 720         return NULL;
 721     }
 722     n = MAX_FINGERPRINT_LEN;
 723     fingerprint_from_pk( pk, fpr, &n );
 724     free_public_key( pk );
 725     p = xmalloc( 2*n+3 );
 726     *p++ = '0';
 727     *p++ = 'x';
 728     for(i=0; i < n; i++ )
 729         sprintf( p+2*i, "%02X", fpr[i] );
 730     p -= 2;
 731     return p;
 732 }
 733
 734 static int
 735 expand_id(const char *id,strlist_t *into,unsigned int flags)
 736 {
 737   struct groupitem *groups;
 738   int count=0;
 739
 740   for(groups=opt.grouplist;groups;groups=groups->next)
 741     {
 742       /* need strcasecmp() here, as this should be localized */
 743       if(strcasecmp(groups->name,id)==0)
 744         {
 745           strlist_t each,sl;
 746
 747           /* this maintains the current utf8-ness */
 748           for(each=groups->values;each;each=each->next)
 749             {
 750               sl=add_to_strlist(into,each->d);
 751               sl->flags=flags;
 752               count++;
 753             }
 754
 755           break;
 756         }
 757     }
 758
 759   return count;
 760 }
 761
 762 /* For simplicity, and to avoid potential loops, we only expand once -
 763    you can't make an alias that points to an alias. */
 764 static strlist_t
 765 expand_group(strlist_t input)
 766 {
 767   strlist_t sl,output=NULL,rover;
 768
 769   for(rover=input;rover;rover=rover->next)
 770     if(expand_id(rover->d,&output,rover->flags)==0)
 771       {
 772         /* Didn't find any groups, so use the existing string */
 773         sl=add_to_strlist(&output,rover->d);
 774         sl->flags=rover->flags;
 775       }
 776
 777   return output;
 778 }
 779
 780
 781 /* Helper for build_pk_list to find and check one key.  This helper is
 782    also used directly in server mode by the RECIPIENTS command.  On
 783    success the new key is added to PK_LIST_ADDR.  NAME is the user id
 784    of the key. USE the requested usage and a set MARK_HIDDEN will mark
 785    the key in the updated list as a hidden recipient. */
 786 gpg_error_t
 787 find_and_check_key (ctrl_t ctrl, const char *name, unsigned int use,
 788                     int mark_hidden, pk_list_t *pk_list_addr)
 789 {
 790   int rc;
 791   PKT_public_key *pk;
 792   int trustlevel;
 793
 794   if (!name || !*name)
 795     return gpg_error (GPG_ERR_INV_USER_ID);
 796
 797   pk = xtrycalloc (1, sizeof *pk);
 798   if (!pk)
 799     return gpg_error_from_syserror ();
 800   pk->req_usage = use;
 801
 802   rc = get_pubkey_byname (ctrl, NULL, pk, name, NULL, NULL, 0, 0);
 803   if (rc)
 804     {
 805       int code;
 806
 807       /* Key not found or other error. */
 808       log_error (_("%s: skipped: %s\n"), name, gpg_strerror (rc) );
 809       switch (gpg_err_code (rc))
 810         {
 811         case GPG_ERR_NO_SECKEY:
 812         case GPG_ERR_NO_PUBKEY:   code =  1; break;
 813         case GPG_ERR_INV_USER_ID: code = 14; break;
 814         default: code = 0; break;
 815         }
 816       send_status_inv_recp (code, name);
 817       free_public_key (pk);
 818       return rc;
 819     }
 820
 821   rc = openpgp_pk_test_algo2 (pk->pubkey_algo, use);
 822   if (rc)
 823     {
 824       /* Key found but not usable for us (e.g. sign-only key). */
 825       send_status_inv_recp (3, name); /* Wrong key usage */
 826       log_error (_("%s: skipped: %s\n"), name, gpg_strerror (rc) );
 827       free_public_key (pk);
 828       return rc;
 829     }
 830
 831   /* Key found and usable.  Check validity. */
 832   trustlevel = get_validity (pk, pk->user_id);
 833   if ( (trustlevel & TRUST_FLAG_DISABLED) )
 834     {
 835       /* Key has been disabled. */
 836       send_status_inv_recp (13, name);
 837       log_info (_("%s: skipped: public key is disabled\n"), name);
 838       free_public_key (pk);
 839       return GPG_ERR_UNUSABLE_PUBKEY;
 840     }
 841
 842   if ( !do_we_trust_pre (pk, trustlevel) )
 843     {
 844       /* We don't trust this key.  */
 845       send_status_inv_recp (10, name);
 846       free_public_key (pk);
 847       return GPG_ERR_UNUSABLE_PUBKEY;
 848     }
 849   /* Note: do_we_trust may have changed the trustlevel. */
 850
 851   /* Skip the actual key if the key is already present in the
 852      list.  */
 853   if (!key_present_in_pk_list (*pk_list_addr, pk))
 854     {
 855       if (!opt.quiet)
 856         log_info (_("%s: skipped: public key already present\n"), name);
 857       free_public_key (pk);
 858     }
 859   else
 860     {
 861       pk_list_t r;
 862
 863       r = xtrymalloc (sizeof *r);
 864       if (!r)
 865         {
 866           rc = gpg_error_from_syserror ();
 867           free_public_key (pk);
 868           return rc;
 869         }
 870       r->pk = pk;
 871       r->next = *pk_list_addr;
 872       r->flags = mark_hidden? 1:0;
 873       *pk_list_addr = r;
 874     }
 875
 876   return 0;
 877 }
 878
 879
 880
 881 /* This is the central function to collect the keys for recipients.
 882    It is thus used to prepare a public key encryption. encrypt-to
 883    keys, default keys and the keys for the actual recipients are all
 884    collected here.  When not in batch mode and no recipient has been
 885    passed on the commandline, the function will also ask for
 886    recipients.
 887
 888    RCPTS is a string list with the recipients; NULL is an allowed
 889    value but not very useful.  Group expansion is done on these names;
 890    they may be in any of the user Id formats we can handle.  The flags
 891    bits for each string in the string list are used for:
 892      Bit 0: This is an encrypt-to recipient.
 893      Bit 1: This is a hidden recipient.
 894
 895    USE is the desired use for the key - usually PUBKEY_USAGE_ENC.
 896
 897    On success a list of keys is stored at the address RET_PK_LIST; the
 898    caller must free this list.  On error the value at this address is
 899    not changed.
 900  */
 901 int
 902 build_pk_list (ctrl_t ctrl,
 903                strlist_t rcpts, PK_LIST *ret_pk_list, unsigned int use )
 904 {
 905   PK_LIST pk_list = NULL;
 906   PKT_public_key *pk=NULL;
 907   int rc=0;
 908   int any_recipients=0;
 909   strlist_t rov,remusr;
 910   char *def_rec = NULL;
 911   char pkstrbuf[PUBKEY_STRING_SIZE];
 912
 913   /* Try to expand groups if any have been defined. */
 914   if (opt.grouplist)
 915     remusr = expand_group (rcpts);
 916   else
 917     remusr = rcpts;
 918
 919   /* Check whether there are any recipients in the list and build the
 920    * list of the encrypt-to ones (we always trust them). */
 921   for ( rov = remusr; rov; rov = rov->next )
 922     {
 923       if ( !(rov->flags & 1) )
 924         {
 925           /* This is a regular recipient; i.e. not an encrypt-to
 926              one. */
 927           any_recipients = 1;
 928
 929           /* Hidden recipients are not allowed while in PGP mode,
 930              issue a warning and switch into GnuPG mode. */
 931           if ((rov->flags&2) && (PGP6 || PGP7 || PGP8))
 932             {
 933               log_info(_("you may not use %s while in %s mode\n"),
 934                        "--hidden-recipient",
 935                        compliance_option_string());
 936
 937               compliance_failure();
 938             }
 939         }
 940       else if ( (use & PUBKEY_USAGE_ENC) && !opt.no_encrypt_to )
 941         {
 942           /* Encryption has been requested and --encrypt-to has not
 943              been disabled.  Check this encrypt-to key. */
 944           pk = xmalloc_clear( sizeof *pk );
 945           pk->req_usage = use;
 946
 947           /* We explicitly allow encrypt-to to an disabled key; thus
 948              we pass 1 for the second last argument and 1 as the last
 949              argument to disable AKL. */
 950           if ( (rc = get_pubkey_byname (ctrl,
 951                                         NULL, pk, rov->d, NULL, NULL, 1, 1)) )
 952             {
 953               free_public_key ( pk ); pk = NULL;
 954               log_error (_("%s: skipped: %s\n"), rov->d, gpg_strerror (rc) );
 955               send_status_inv_recp (0, rov->d);
 956               goto fail;
 957             }
 958           else if ( !(rc=openpgp_pk_test_algo2 (pk->pubkey_algo, use)) )
 959             {
 960               /* Skip the actual key if the key is already present
 961                * in the list.  Add it to our list if not. */
 962               if (key_present_in_pk_list(pk_list, pk) == 0)
 963                 {
 964                   free_public_key (pk); pk = NULL;
 965                   if (!opt.quiet)
 966                     log_info (_("%s: skipped: public key already present\n"),
 967                               rov->d);
 968                 }
 969               else
 970                 {
 971                   PK_LIST r;
 972                   r = xmalloc( sizeof *r );
 973                   r->pk = pk; pk = NULL;
 974                   r->next = pk_list;
 975                   r->flags = (rov->flags&2)?1:0;
 976                   pk_list = r;
 977
 978                   /* Hidden encrypt-to recipients are not allowed while
 979                      in PGP mode, issue a warning and switch into
 980                      GnuPG mode. */
 981                   if ((r->flags&1) && (PGP6 || PGP7 || PGP8))
 982                     {
 983                       log_info(_("you may not use %s while in %s mode\n"),
 984                                "--hidden-encrypt-to",
 985                                compliance_option_string());
 986
 987                       compliance_failure();
 988                     }
 989                 }
 990             }
 991           else
 992             {
 993               /* The public key is not usable for encryption. */
 994               free_public_key( pk ); pk = NULL;
 995               log_error(_("%s: skipped: %s\n"), rov->d, gpg_strerror (rc) );
 996               send_status_inv_recp (3, rov->d); /* Wrong key usage */
 997               goto fail;
 998             }
 999         }
1000     }
1001
1002   /* If we don't have any recipients yet and we are not in batch mode
1003      drop into interactive selection mode. */
1004   if ( !any_recipients && !opt.batch )
1005     {
1006       int have_def_rec;
1007       char *answer = NULL;
1008       strlist_t backlog = NULL;
1009
1010       if (pk_list)
1011         any_recipients = 1;
1012       def_rec = default_recipient();
1013       have_def_rec = !!def_rec;
1014       if ( !have_def_rec )
1015         tty_printf(_("You did not specify a user ID. (you may use \"-r\")\n"));
1016
1017       for (;;)
1018         {
1019           rc = 0;
1020           xfree(answer);
1021           if ( have_def_rec )
1022             {
1023               /* A default recipient is taken as the first entry. */
1024               answer = def_rec;
1025               def_rec = NULL;
1026             }
1027           else if (backlog)
1028             {
1029               /* This is part of our trick to expand and display groups. */
1030               answer = strlist_pop (&backlog);
1031             }
1032           else
1033             {
1034               /* Show the list of already collected recipients and ask
1035                  for more. */
1036               PK_LIST iter;
1037
1038               tty_printf("\n");
1039               tty_printf(_("Current recipients:\n"));
1040               for (iter=pk_list;iter;iter=iter->next)
1041                 {
1042                   u32 keyid[2];
1043
1044                   keyid_from_pk(iter->pk,keyid);
1045                   tty_printf ("%s/%s %s \"",
1046                               pubkey_string (iter->pk,
1047                                              pkstrbuf, sizeof pkstrbuf),
1048                               keystr(keyid),
1049                               datestr_from_pk (iter->pk));
1050
1051                   if (iter->pk->user_id)
1052                     tty_print_utf8_string(iter->pk->user_id->name,
1053                                           iter->pk->user_id->len);
1054                   else
1055                     {
1056                       size_t n;
1057                       char *p = get_user_id( keyid, &n );
1058                       tty_print_utf8_string( p, n );
1059                       xfree(p);
1060                     }
1061                   tty_printf("\"\n");
1062                 }
1063
1064               answer = cpr_get_utf8("pklist.user_id.enter",
1065                                     _("\nEnter the user ID.  "
1066                                       "End with an empty line: "));
1067               trim_spaces(answer);
1068               cpr_kill_prompt();
1069             }
1070
1071           if ( !answer || !*answer )
1072             {
1073               xfree(answer);
1074               break;  /* No more recipients entered - get out of loop. */
1075             }
1076
1077           /* Do group expand here too.  The trick here is to continue
1078              the loop if any expansion occured.  The code above will
1079              then list all expanded keys. */
1080           if (expand_id(answer,&backlog,0))
1081             continue;
1082
1083           /* Get and check key for the current name. */
1084           free_public_key (pk);
1085           pk = xmalloc_clear( sizeof *pk );
1086           pk->req_usage = use;
1087           rc = get_pubkey_byname (ctrl, NULL, pk, answer, NULL, NULL, 0, 0 );
1088           if (rc)
1089             tty_printf(_("No such user ID.\n"));
1090           else if ( !(rc=openpgp_pk_test_algo2 (pk->pubkey_algo, use)) )
1091             {
1092               if ( have_def_rec )
1093                 {
1094                   /* No validation for a default recipient. */
1095                   if (!key_present_in_pk_list(pk_list, pk))
1096                     {
1097                       free_public_key (pk);
1098                       pk = NULL;
1099                       log_info (_("skipped: public key "
1100                                   "already set as default recipient\n") );
1101                     }
1102                   else
1103                     {
1104                       PK_LIST r = xmalloc (sizeof *r);
1105                       r->pk = pk; pk = NULL;
1106                       r->next = pk_list;
1107                       r->flags = 0; /* No throwing default ids. */
1108                       pk_list = r;
1109                     }
1110                   any_recipients = 1;
1111                   continue;
1112                 }
1113               else
1114                 { /* Check validity of this key. */
1115                   int trustlevel;
1116
1117                   trustlevel = get_validity (pk, pk->user_id);
1118                   if ( (trustlevel & TRUST_FLAG_DISABLED) )
1119                     {
1120                       tty_printf (_("Public key is disabled.\n") );
1121                     }
1122                   else if ( do_we_trust_pre (pk, trustlevel) )
1123                     {
1124                       /* Skip the actual key if the key is already
1125                        * present in the list */
1126                       if (!key_present_in_pk_list(pk_list, pk))
1127                         {
1128                           free_public_key (pk);
1129                           pk = NULL;
1130                           log_info(_("skipped: public key already set\n") );
1131                         }
1132                       else
1133                         {
1134                           PK_LIST r;
1135                           r = xmalloc( sizeof *r );
1136                           r->pk = pk; pk = NULL;
1137                           r->next = pk_list;
1138                           r->flags = 0; /* No throwing interactive ids. */
1139                           pk_list = r;
1140                         }
1141                       any_recipients = 1;
1142                       continue;
1143                     }
1144                 }
1145             }
1146           xfree(def_rec); def_rec = NULL;
1147           have_def_rec = 0;
1148         }
1149       if ( pk )
1150         {
1151           free_public_key( pk );
1152           pk = NULL;
1153         }
1154     }
1155   else if ( !any_recipients && (def_rec = default_recipient()) )
1156     {
1157       /* We are in batch mode and have only a default recipient. */
1158       pk = xmalloc_clear( sizeof *pk );
1159       pk->req_usage = use;
1160
1161       /* The default recipient is allowed to be disabled; thus pass 1
1162          as second last argument.  We also don't want an AKL. */
1163       rc = get_pubkey_byname (ctrl, NULL, pk, def_rec, NULL, NULL, 1, 1);
1164       if (rc)
1165         log_error(_("unknown default recipient \"%s\"\n"), def_rec );
1166       else if ( !(rc=openpgp_pk_test_algo2(pk->pubkey_algo, use)) )
1167         {
1168           /* Mark any_recipients here since the default recipient
1169              would have been used if it wasn't already there.  It
1170              doesn't really matter if we got this key from the default
1171              recipient or an encrypt-to. */
1172           any_recipients = 1;
1173           if (!key_present_in_pk_list(pk_list, pk))
1174             log_info (_("skipped: public key already set "
1175                         "as default recipient\n"));
1176           else
1177             {
1178               PK_LIST r = xmalloc( sizeof *r );
1179               r->pk = pk; pk = NULL;
1180               r->next = pk_list;
1181               r->flags = 0; /* No throwing default ids. */
1182               pk_list = r;
1183             }
1184         }
1185       if ( pk )
1186         {
1187           free_public_key( pk );
1188           pk = NULL;
1189         }
1190       xfree(def_rec); def_rec = NULL;
1191     }
1192   else
1193     {
1194       /* General case: Check all keys. */
1195       any_recipients = 0;
1196       for (; remusr; remusr = remusr->next )
1197         {
1198           if ( (remusr->flags & 1) )
1199             continue; /* encrypt-to keys are already handled. */
1200
1201           rc = find_and_check_key (ctrl, remusr->d, use, !!(remusr->flags&2),
1202                                    &pk_list);
1203           if (rc)
1204             goto fail;
1205           any_recipients = 1;
1206         }
1207     }
1208
1209   if ( !rc && !any_recipients )
1210     {
1211       log_error(_("no valid addressees\n"));
1212       write_status_text (STATUS_NO_RECP, "0");
1213       rc = GPG_ERR_NO_USER_ID;
1214     }
1215
1216  fail:
1217
1218   if ( rc )
1219     release_pk_list( pk_list );
1220   else
1221     *ret_pk_list = pk_list;
1222   if (opt.grouplist)
1223     free_strlist(remusr);
1224   return rc;
1225 }
1226
1227
1228 /* In pgp6 mode, disallow all ciphers except IDEA (1), 3DES (2), and
1229    CAST5 (3), all hashes except MD5 (1), SHA1 (2), and RIPEMD160 (3),
1230    and all compressions except none (0) and ZIP (1).  pgp7 and pgp8
1231    mode expands the cipher list to include AES128 (7), AES192 (8),
1232    AES256 (9), and TWOFISH (10).  pgp8 adds the SHA-256 hash (8).  For
1233    a true PGP key all of this is unneeded as they are the only items
1234    present in the preferences subpacket, but checking here covers the
1235    weird case of encrypting to a key that had preferences from a
1236    different implementation which was then used with PGP.  I am not
1237    completely comfortable with this as the right thing to do, as it
1238    slightly alters the list of what the user is supposedly requesting.
1239    It is not against the RFC however, as the preference chosen will
1240    never be one that the user didn't specify somewhere ("The
1241    implementation may use any mechanism to pick an algorithm in the
1242    intersection"), and PGP has no mechanism to fix such a broken
1243    preference list, so I'm including it. -dms */
1244
1245 int
1246 algo_available( preftype_t preftype, int algo, const union pref_hint *hint)
1247 {
1248   if( preftype == PREFTYPE_SYM )
1249     {
1250       if(PGP6 && (algo != CIPHER_ALGO_IDEA
1251                   && algo != CIPHER_ALGO_3DES
1252                   && algo != CIPHER_ALGO_CAST5))
1253         return 0;
1254
1255       if(PGP7 && (algo != CIPHER_ALGO_IDEA
1256                   && algo != CIPHER_ALGO_3DES
1257                   && algo != CIPHER_ALGO_CAST5
1258                   && algo != CIPHER_ALGO_AES
1259                   && algo != CIPHER_ALGO_AES192
1260                   && algo != CIPHER_ALGO_AES256
1261                   && algo != CIPHER_ALGO_TWOFISH))
1262         return 0;
1263
1264       /* PGP8 supports all the ciphers we do.. */
1265
1266       return algo && !openpgp_cipher_test_algo ( algo );
1267     }
1268   else if( preftype == PREFTYPE_HASH )
1269     {
1270       if (hint && hint->digest_length)
1271         {
1272           if (hint->digest_length!=20 || opt.flags.dsa2)
1273             {
1274               /* If --enable-dsa2 is set or the hash isn't 160 bits
1275                  (which implies DSA2), then we'll accept a hash that
1276                  is larger than we need.  Otherwise we won't accept
1277                  any hash that isn't exactly the right size. */
1278               if (hint->digest_length > gcry_md_get_algo_dlen (algo))
1279                 return 0;
1280             }
1281           else if (hint->digest_length != gcry_md_get_algo_dlen (algo))
1282             return 0;
1283         }
1284
1285       if((PGP6 || PGP7) && (algo != DIGEST_ALGO_MD5
1286                             && algo != DIGEST_ALGO_SHA1
1287                             && algo != DIGEST_ALGO_RMD160))
1288         return 0;
1289
1290
1291       if(PGP8 && (algo != DIGEST_ALGO_MD5
1292                   && algo != DIGEST_ALGO_SHA1
1293                   && algo != DIGEST_ALGO_RMD160
1294                   && algo != DIGEST_ALGO_SHA256))
1295         return 0;
1296
1297       return algo && !openpgp_md_test_algo (algo);
1298     }
1299   else if( preftype == PREFTYPE_ZIP )
1300     {
1301       if((PGP6 || PGP7) && (algo != COMPRESS_ALGO_NONE
1302                             && algo != COMPRESS_ALGO_ZIP))
1303         return 0;
1304
1305       /* PGP8 supports all the compression algos we do */
1306
1307       return !check_compress_algo( algo );
1308     }
1309   else
1310     return 0;
1311 }
1312
1313 /****************
1314  * Return -1 if we could not find an algorithm.
1315  */
1316 int
1317 select_algo_from_prefs(PK_LIST pk_list, int preftype,
1318                        int request, const union pref_hint *hint)
1319 {
1320   PK_LIST pkr;
1321   u32 bits[8];
1322   const prefitem_t *prefs;
1323   int result=-1,i;
1324   u16 scores[256];
1325
1326   if( !pk_list )
1327     return -1;
1328
1329   memset(bits,0xFF,sizeof(bits));
1330   memset(scores,0,sizeof(scores));
1331
1332   for( pkr = pk_list; pkr; pkr = pkr->next )
1333     {
1334       u32 mask[8];
1335       int rank=1,implicit=-1;
1336
1337       memset(mask,0,sizeof(mask));
1338
1339       switch(preftype)
1340         {
1341         case PREFTYPE_SYM:
1342           /* IDEA is implicitly there for v3 keys with v3 selfsigs if
1343              --pgp2 mode is on.  This was a 2440 thing that was
1344              dropped from 4880 but is still relevant to GPG's 1991
1345              support.  All this doesn't mean IDEA is actually
1346              available, of course. */
1347           implicit=CIPHER_ALGO_3DES;
1348
1349           break;
1350
1351         case PREFTYPE_HASH:
1352           /* While I am including this code for completeness, note
1353              that currently --pgp2 mode locks the hash at MD5, so this
1354              code will never even be called.  Even if the hash wasn't
1355              locked at MD5, we don't support sign+encrypt in --pgp2
1356              mode, and that's the only time PREFTYPE_HASH is used
1357              anyway. -dms */
1358
1359           implicit=DIGEST_ALGO_SHA1;
1360
1361           break;
1362
1363         case PREFTYPE_ZIP:
1364           /* Uncompressed is always an option. */
1365           implicit=COMPRESS_ALGO_NONE;
1366         }
1367
1368       if (pkr->pk->user_id) /* selected by user ID */
1369         prefs = pkr->pk->user_id->prefs;
1370       else
1371         prefs = pkr->pk->prefs;
1372
1373       if( prefs )
1374         {
1375           for (i=0; prefs[i].type; i++ )
1376             {
1377               if( prefs[i].type == preftype )
1378                 {
1379                   /* Make sure all scores don't add up past 0xFFFF
1380                      (and roll around) */
1381                   if(rank+scores[prefs[i].value]<=0xFFFF)
1382                     scores[prefs[i].value]+=rank;
1383                   else
1384                     scores[prefs[i].value]=0xFFFF;
1385
1386                   mask[prefs[i].value/32] |= 1<<(prefs[i].value%32);
1387
1388                   rank++;
1389
1390                   /* We saw the implicit algorithm, so we don't need
1391                      tack it on the end ourselves. */
1392                   if(implicit==prefs[i].value)
1393                     implicit=-1;
1394                 }
1395             }
1396         }
1397
1398       if(rank==1 && preftype==PREFTYPE_ZIP)
1399         {
1400           /* If the compression preferences are not present, they are
1401              assumed to be ZIP, Uncompressed (RFC4880:13.3.1) */
1402           scores[1]=1; /* ZIP is first choice */
1403           scores[0]=2; /* Uncompressed is second choice */
1404           mask[0]|=3;
1405         }
1406
1407       /* If the key didn't have the implicit algorithm listed
1408          explicitly, add it here at the tail of the list. */
1409       if(implicit>-1)
1410         {
1411           scores[implicit]+=rank;
1412           mask[implicit/32] |= 1<<(implicit%32);
1413         }
1414
1415       for(i=0;i<8;i++)
1416         bits[i]&=mask[i];
1417     }
1418
1419   /* We've now scored all of the algorithms, and the usable ones have
1420      bits set.  Let's pick the winner. */
1421
1422   /* The caller passed us a request.  Can we use it? */
1423   if(request>-1 && (bits[request/32] & (1<<(request%32))) &&
1424      algo_available(preftype,request,hint))
1425     result=request;
1426
1427   if(result==-1)
1428     {
1429       /* If we have personal prefs set, use them. */
1430       prefs=NULL;
1431       if(preftype==PREFTYPE_SYM && opt.personal_cipher_prefs)
1432         prefs=opt.personal_cipher_prefs;
1433       else if(preftype==PREFTYPE_HASH && opt.personal_digest_prefs)
1434         prefs=opt.personal_digest_prefs;
1435       else if(preftype==PREFTYPE_ZIP && opt.personal_compress_prefs)
1436         prefs=opt.personal_compress_prefs;
1437
1438       if( prefs )
1439         for(i=0; prefs[i].type; i++ )
1440           {
1441             if(bits[prefs[i].value/32] & (1<<(prefs[i].value%32))
1442                && algo_available( preftype, prefs[i].value, hint))
1443               {
1444                 result = prefs[i].value;
1445                 break;
1446               }
1447           }
1448     }
1449
1450   if(result==-1)
1451     {
1452       unsigned int best=-1;
1453
1454       /* At this point, we have not selected an algorithm due to a
1455          special request or via personal prefs.  Pick the highest
1456          ranked algorithm (i.e. the one with the lowest score). */
1457
1458       if(preftype==PREFTYPE_HASH && scores[DIGEST_ALGO_MD5])
1459         {
1460           /* "If you are building an authentication system, the recipient
1461              may specify a preferred signing algorithm. However, the
1462              signer would be foolish to use a weak algorithm simply
1463              because the recipient requests it." (RFC4880:14).  If any
1464              other hash algorithm is available, pretend that MD5 isn't.
1465              Note that if the user intentionally chose MD5 by putting it
1466              in their personal prefs, then we do what the user said (as we
1467              never reach this code). */
1468
1469           for(i=DIGEST_ALGO_MD5+1;i<256;i++)
1470             if(scores[i])
1471               {
1472                 scores[DIGEST_ALGO_MD5]=0;
1473                 break;
1474               }
1475         }
1476
1477       for(i=0;i<256;i++)
1478         {
1479           /* Note the '<' here.  This means in case of a tie, we will
1480              favor the lower algorithm number.  We have a choice
1481              between the lower number (probably an older algorithm
1482              with more time in use), or the higher number (probably a
1483              newer algorithm with less time in use).  Older is
1484              probably safer here, even though the newer algorithms
1485              tend to be "stronger". */
1486           if(scores[i] && scores[i]<best
1487              && (bits[i/32] & (1<<(i%32)))
1488              && algo_available(preftype,i,hint))
1489             {
1490               best=scores[i];
1491               result=i;
1492             }
1493         }
1494     }
1495
1496   return result;
1497 }
1498
1499 /*
1500  * Select the MDC flag from the pk_list.  We can only use MDC if all
1501  * recipients support this feature.
1502  */
1503 int
1504 select_mdc_from_pklist (PK_LIST pk_list)
1505 {
1506   PK_LIST pkr;
1507
1508   if ( !pk_list )
1509     return 0;
1510
1511   for (pkr = pk_list; pkr; pkr = pkr->next)
1512     {
1513       int mdc;
1514
1515       if (pkr->pk->user_id) /* selected by user ID */
1516         mdc = pkr->pk->user_id->flags.mdc;
1517       else
1518         mdc = pkr->pk->flags.mdc;
1519       if (!mdc)
1520         return 0;  /* At least one recipient does not support it. */
1521     }
1522   return 1; /* Can be used. */
1523 }
1524
1525
1526 /* Print a warning for all keys in PK_LIST missing the MDC feature. */
1527 void
1528 warn_missing_mdc_from_pklist (PK_LIST pk_list)
1529 {
1530   PK_LIST pkr;
1531
1532   for (pkr = pk_list; pkr; pkr = pkr->next)
1533     {
1534       int mdc;
1535
1536       if (pkr->pk->user_id) /* selected by user ID */
1537         mdc = pkr->pk->user_id->flags.mdc;
1538       else
1539         mdc = pkr->pk->flags.mdc;
1540       if (!mdc)
1541         log_info (_("Note: key %s has no %s feature\n"),
1542                   keystr_from_pk (pkr->pk), "MDC");
1543     }
1544 }
1545
1546 void
1547 warn_missing_aes_from_pklist (PK_LIST pk_list)
1548 {
1549   PK_LIST pkr;
1550
1551   for (pkr = pk_list; pkr; pkr = pkr->next)
1552     {
1553       const prefitem_t *prefs;
1554       int i;
1555       int gotit = 0;
1556
1557       prefs = pkr->pk->user_id? pkr->pk->user_id->prefs : pkr->pk->prefs;
1558       if (prefs)
1559         {
1560           for (i=0; !gotit && prefs[i].type; i++ )
1561             if (prefs[i].type == PREFTYPE_SYM
1562                 && prefs[i].value == CIPHER_ALGO_AES)
1563               gotit++;
1564         }
1565       if (!gotit)
1566         log_info (_("Note: key %s has no preference for %s\n"),
1567                   keystr_from_pk (pkr->pk), "AES");
1568     }
1569 }