gpg: Extend TRUST_foo status lines with the trust model.
[gnupg.git] / 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
27 #include "gpg.h"
28 #include "options.h"
29 #include "packet.h"
30 #include "status.h"
31 #include "keydb.h"
32 #include "util.h"
33 #include "main.h"
34 #include "trustdb.h"
35 #include "ttyio.h"
36 #include "status.h"
37 #include "photoid.h"
38 #include "i18n.h"
39 #include "tofu.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 because 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_pubkey_byfprint(NULL, &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 /* Write a TRUST_foo status line inclduing the validation model.  */
509 static void
510 write_trust_status (int statuscode, int trustlevel)
511 {
512   int tm;
513
514   /* For the combined tofu+pgp method, we return the trust model which
515    * was responsible for the trustlevel.  */
516   if (opt.trust_model == TM_TOFU_PGP)
517     tm = (trustlevel & TRUST_FLAG_TOFU_BASED)? TM_TOFU : TM_PGP;
518   else
519     tm = opt.trust_model;
520   write_status_strings (statuscode, "0 ", trust_model_string (tm), NULL);
521 }
522
523
524 /****************
525  * Check whether we can trust this signature.
526  * Returns an error code if we should not trust this signature.
527  */
528 int
529 check_signatures_trust( PKT_signature *sig )
530 {
531   PKT_public_key *pk = xmalloc_clear( sizeof *pk );
532   unsigned int trustlevel = TRUST_UNKNOWN;
533   int rc=0;
534
535   rc = get_pubkey( pk, sig->keyid );
536   if (rc)
537     { /* this should not happen */
538       log_error("Ooops; the key vanished  - can't check the trust\n");
539       rc = GPG_ERR_NO_PUBKEY;
540       goto leave;
541     }
542
543   if ( opt.trust_model==TM_ALWAYS )
544     {
545       if( !opt.quiet )
546         log_info(_("WARNING: Using untrusted key!\n"));
547       if (opt.with_fingerprint)
548         print_fingerprint (NULL, pk, 1);
549       goto leave;
550     }
551
552   if(pk->flags.maybe_revoked && !pk->flags.revoked)
553     log_info(_("WARNING: this key might be revoked (revocation key"
554                " not present)\n"));
555
556   trustlevel = get_validity (pk, NULL, sig, 1);
557
558   if ( (trustlevel & TRUST_FLAG_REVOKED) )
559     {
560       write_status( STATUS_KEYREVOKED );
561       if(pk->flags.revoked == 2)
562         log_info(_("WARNING: This key has been revoked by its"
563                    " designated revoker!\n"));
564       else
565         log_info(_("WARNING: This key has been revoked by its owner!\n"));
566       log_info(_("         This could mean that the signature is forged.\n"));
567       show_revocation_reason( pk, 0 );
568     }
569   else if ((trustlevel & TRUST_FLAG_SUB_REVOKED) )
570     {
571       write_status( STATUS_KEYREVOKED );
572       log_info(_("WARNING: This subkey has been revoked by its owner!\n"));
573       show_revocation_reason( pk, 0 );
574     }
575
576   if ((trustlevel & TRUST_FLAG_DISABLED))
577     log_info (_("Note: This key has been disabled.\n"));
578
579   /* If we have PKA information adjust the trustlevel. */
580   if (sig->pka_info && sig->pka_info->valid)
581     {
582       unsigned char fpr[MAX_FINGERPRINT_LEN];
583       PKT_public_key *primary_pk;
584       size_t fprlen;
585       int okay;
586
587
588       primary_pk = xmalloc_clear (sizeof *primary_pk);
589       get_pubkey (primary_pk, pk->main_keyid);
590       fingerprint_from_pk (primary_pk, fpr, &fprlen);
591       free_public_key (primary_pk);
592
593       if ( fprlen == 20 && !memcmp (sig->pka_info->fpr, fpr, 20) )
594         {
595           okay = 1;
596           write_status_text (STATUS_PKA_TRUST_GOOD, sig->pka_info->email);
597           log_info (_("Note: Verified signer's address is '%s'\n"),
598                     sig->pka_info->email);
599         }
600       else
601         {
602           okay = 0;
603           write_status_text (STATUS_PKA_TRUST_BAD, sig->pka_info->email);
604           log_info (_("Note: Signer's address '%s' "
605                       "does not match DNS entry\n"), sig->pka_info->email);
606         }
607
608       switch ( (trustlevel & TRUST_MASK) )
609         {
610         case TRUST_UNKNOWN:
611         case TRUST_UNDEFINED:
612         case TRUST_MARGINAL:
613           if (okay && opt.verify_options&VERIFY_PKA_TRUST_INCREASE)
614             {
615               trustlevel = ((trustlevel & ~TRUST_MASK) | TRUST_FULLY);
616               log_info (_("trustlevel adjusted to FULL"
617                           " due to valid PKA info\n"));
618             }
619           /* (fall through) */
620         case TRUST_FULLY:
621           if (!okay)
622             {
623               trustlevel = ((trustlevel & ~TRUST_MASK) | TRUST_NEVER);
624               log_info (_("trustlevel adjusted to NEVER"
625                           " due to bad PKA info\n"));
626             }
627           break;
628         }
629     }
630
631   /* Now let the user know what up with the trustlevel. */
632   switch ( (trustlevel & TRUST_MASK) )
633     {
634     case TRUST_EXPIRED:
635       log_info(_("Note: This key has expired!\n"));
636       print_fingerprint (NULL, pk, 1);
637       break;
638
639     default:
640       log_error ("invalid trustlevel %u returned from validation layer\n",
641                  trustlevel);
642       /* fall thru */
643     case TRUST_UNKNOWN:
644     case TRUST_UNDEFINED:
645       write_trust_status (STATUS_TRUST_UNDEFINED, trustlevel);
646       log_info(_("WARNING: This key is not certified with"
647                  " a trusted signature!\n"));
648       log_info(_("         There is no indication that the "
649                  "signature belongs to the owner.\n" ));
650       print_fingerprint (NULL, pk, 1);
651       break;
652
653     case TRUST_NEVER:
654       /* currently we won't get that status */
655       write_trust_status (STATUS_TRUST_NEVER, trustlevel);
656       log_info(_("WARNING: We do NOT trust this key!\n"));
657       log_info(_("         The signature is probably a FORGERY.\n"));
658       if (opt.with_fingerprint)
659         print_fingerprint (NULL, pk, 1);
660       rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
661       break;
662
663     case TRUST_MARGINAL:
664       write_trust_status (STATUS_TRUST_MARGINAL, trustlevel);
665       log_info(_("WARNING: This key is not certified with"
666                  " sufficiently trusted signatures!\n"));
667       log_info(_("         It is not certain that the"
668                  " signature belongs to the owner.\n" ));
669       print_fingerprint (NULL, pk, 1);
670       break;
671
672     case TRUST_FULLY:
673       write_trust_status (STATUS_TRUST_FULLY, trustlevel);
674       if (opt.with_fingerprint)
675         print_fingerprint (NULL, pk, 1);
676       break;
677
678     case TRUST_ULTIMATE:
679       write_trust_status (STATUS_TRUST_ULTIMATE, trustlevel);
680       if (opt.with_fingerprint)
681         print_fingerprint (NULL, pk, 1);
682       break;
683     }
684
685  leave:
686   free_public_key( pk );
687   return rc;
688 }
689
690
691 void
692 release_pk_list (pk_list_t pk_list)
693 {
694   PK_LIST pk_rover;
695
696   for ( ; pk_list; pk_list = pk_rover)
697     {
698       pk_rover = pk_list->next;
699       free_public_key ( pk_list->pk );
700       xfree ( pk_list );
701     }
702 }
703
704
705 static int
706 key_present_in_pk_list(PK_LIST pk_list, PKT_public_key *pk)
707 {
708     for( ; pk_list; pk_list = pk_list->next)
709         if (cmp_public_keys(pk_list->pk, pk) == 0)
710             return 0;
711
712     return -1;
713 }
714
715
716 /****************
717  * Return a malloced string with a default recipient if there is any
718  */
719 static char *
720 default_recipient(ctrl_t ctrl)
721 {
722     PKT_public_key *pk;
723     byte fpr[MAX_FINGERPRINT_LEN+1];
724     size_t n;
725     char *p;
726     int i;
727
728     if( opt.def_recipient )
729         return xstrdup( opt.def_recipient );
730     if( !opt.def_recipient_self )
731         return NULL;
732     pk = xmalloc_clear( sizeof *pk );
733     i = get_seckey_default (ctrl, pk);
734     if( i ) {
735         free_public_key( pk );
736         return NULL;
737     }
738     n = MAX_FINGERPRINT_LEN;
739     fingerprint_from_pk( pk, fpr, &n );
740     free_public_key( pk );
741     p = xmalloc( 2*n+3 );
742     *p++ = '0';
743     *p++ = 'x';
744     for(i=0; i < n; i++ )
745         sprintf( p+2*i, "%02X", fpr[i] );
746     p -= 2;
747     return p;
748 }
749
750 static int
751 expand_id(const char *id,strlist_t *into,unsigned int flags)
752 {
753   struct groupitem *groups;
754   int count=0;
755
756   for(groups=opt.grouplist;groups;groups=groups->next)
757     {
758       /* need strcasecmp() here, as this should be localized */
759       if(strcasecmp(groups->name,id)==0)
760         {
761           strlist_t each,sl;
762
763           /* this maintains the current utf8-ness */
764           for(each=groups->values;each;each=each->next)
765             {
766               sl=add_to_strlist(into,each->d);
767               sl->flags=flags;
768               count++;
769             }
770
771           break;
772         }
773     }
774
775   return count;
776 }
777
778 /* For simplicity, and to avoid potential loops, we only expand once -
779    you can't make an alias that points to an alias. */
780 static strlist_t
781 expand_group(strlist_t input)
782 {
783   strlist_t sl,output=NULL,rover;
784
785   for(rover=input;rover;rover=rover->next)
786     if(expand_id(rover->d,&output,rover->flags)==0)
787       {
788         /* Didn't find any groups, so use the existing string */
789         sl=add_to_strlist(&output,rover->d);
790         sl->flags=rover->flags;
791       }
792
793   return output;
794 }
795
796
797 /* Helper for build_pk_list to find and check one key.  This helper is
798    also used directly in server mode by the RECIPIENTS command.  On
799    success the new key is added to PK_LIST_ADDR.  NAME is the user id
800    of the key. USE the requested usage and a set MARK_HIDDEN will mark
801    the key in the updated list as a hidden recipient. */
802 gpg_error_t
803 find_and_check_key (ctrl_t ctrl, const char *name, unsigned int use,
804                     int mark_hidden, pk_list_t *pk_list_addr)
805 {
806   int rc;
807   PKT_public_key *pk;
808   int trustlevel;
809
810   if (!name || !*name)
811     return gpg_error (GPG_ERR_INV_USER_ID);
812
813   pk = xtrycalloc (1, sizeof *pk);
814   if (!pk)
815     return gpg_error_from_syserror ();
816   pk->req_usage = use;
817
818   rc = get_pubkey_byname (ctrl, NULL, pk, name, NULL, NULL, 0, 0);
819   if (rc)
820     {
821       int code;
822
823       /* Key not found or other error. */
824       log_error (_("%s: skipped: %s\n"), name, gpg_strerror (rc) );
825       switch (gpg_err_code (rc))
826         {
827         case GPG_ERR_NO_SECKEY:
828         case GPG_ERR_NO_PUBKEY:   code =  1; break;
829         case GPG_ERR_INV_USER_ID: code = 14; break;
830         default: code = 0; break;
831         }
832       send_status_inv_recp (code, name);
833       free_public_key (pk);
834       return rc;
835     }
836
837   rc = openpgp_pk_test_algo2 (pk->pubkey_algo, use);
838   if (rc)
839     {
840       /* Key found but not usable for us (e.g. sign-only key). */
841       send_status_inv_recp (3, name); /* Wrong key usage */
842       log_error (_("%s: skipped: %s\n"), name, gpg_strerror (rc) );
843       free_public_key (pk);
844       return rc;
845     }
846
847   /* Key found and usable.  Check validity. */
848   trustlevel = get_validity (pk, pk->user_id, NULL, 1);
849   if ( (trustlevel & TRUST_FLAG_DISABLED) )
850     {
851       /* Key has been disabled. */
852       send_status_inv_recp (13, name);
853       log_info (_("%s: skipped: public key is disabled\n"), name);
854       free_public_key (pk);
855       return GPG_ERR_UNUSABLE_PUBKEY;
856     }
857
858   if ( !do_we_trust_pre (pk, trustlevel) )
859     {
860       /* We don't trust this key.  */
861       send_status_inv_recp (10, name);
862       free_public_key (pk);
863       return GPG_ERR_UNUSABLE_PUBKEY;
864     }
865   /* Note: do_we_trust may have changed the trustlevel. */
866
867   /* Skip the actual key if the key is already present in the
868      list.  */
869   if (!key_present_in_pk_list (*pk_list_addr, pk))
870     {
871       if (!opt.quiet)
872         log_info (_("%s: skipped: public key already present\n"), name);
873       free_public_key (pk);
874     }
875   else
876     {
877       pk_list_t r;
878
879       r = xtrymalloc (sizeof *r);
880       if (!r)
881         {
882           rc = gpg_error_from_syserror ();
883           free_public_key (pk);
884           return rc;
885         }
886       r->pk = pk;
887       r->next = *pk_list_addr;
888       r->flags = mark_hidden? 1:0;
889       *pk_list_addr = r;
890     }
891
892   return 0;
893 }
894
895
896
897 /* This is the central function to collect the keys for recipients.
898    It is thus used to prepare a public key encryption. encrypt-to
899    keys, default keys and the keys for the actual recipients are all
900    collected here.  When not in batch mode and no recipient has been
901    passed on the commandline, the function will also ask for
902    recipients.
903
904    RCPTS is a string list with the recipients; NULL is an allowed
905    value but not very useful.  Group expansion is done on these names;
906    they may be in any of the user Id formats we can handle.  The flags
907    bits for each string in the string list are used for:
908      Bit 0 (PK_LIST_ENCRYPT_TO): This is an encrypt-to recipient.
909      Bit 1 (PK_LIST_HIDDEN)    : This is a hidden recipient.
910
911    On success a list of keys is stored at the address RET_PK_LIST; the
912    caller must free this list.  On error the value at this address is
913    not changed.
914  */
915 int
916 build_pk_list (ctrl_t ctrl, strlist_t rcpts, PK_LIST *ret_pk_list)
917 {
918   PK_LIST pk_list = NULL;
919   PKT_public_key *pk=NULL;
920   int rc=0;
921   int any_recipients=0;
922   strlist_t rov,remusr;
923   char *def_rec = NULL;
924   char pkstrbuf[PUBKEY_STRING_SIZE];
925
926   /* Try to expand groups if any have been defined. */
927   if (opt.grouplist)
928     remusr = expand_group (rcpts);
929   else
930     remusr = rcpts;
931
932   /* XXX: Change this function to use get_pubkeys instead of
933      get_pubkey_byname to detect ambiguous key specifications and warn
934      about duplicate keyblocks.  For ambiguous key specifications on
935      the command line or provided interactively, prompt the user to
936      select the best key.  If a key specification is ambiguous and we
937      are in batch mode, die.  */
938
939   if (opt.encrypt_to_default_key)
940     {
941       static int warned;
942
943       const char *default_key = parse_def_secret_key (ctrl);
944       if (default_key)
945         {
946           PK_LIST r = xmalloc_clear (sizeof *r);
947
948           r->pk = xmalloc_clear (sizeof *r->pk);
949           r->pk->req_usage = PUBKEY_USAGE_ENC;
950
951           rc = get_pubkey_byname (ctrl, NULL, r->pk, default_key,
952                                    NULL, NULL, 0, 1);
953           if (rc)
954             {
955               xfree (r->pk);
956               xfree (r);
957
958               log_error (_("can't encrypt to '%s'\n"), default_key);
959               if (!opt.quiet)
960                 log_info (_("(check argument of option '%s')\n"),
961                           "--default-key");
962             }
963           else
964             {
965               r->next = pk_list;
966               r->flags = 0;
967               pk_list = r;
968             }
969         }
970       else if (opt.def_secret_key)
971         {
972           if (! warned)
973             log_info (_("option '%s' given, but no valid default keys given\n"),
974                       "--encrypt-to-default-key");
975           warned = 1;
976         }
977       else
978         {
979           if (! warned)
980             log_info (_("option '%s' given, but option '%s' not given\n"),
981                       "--encrypt-to-default-key", "--default-key");
982           warned = 1;
983         }
984     }
985
986   /* Check whether there are any recipients in the list and build the
987    * list of the encrypt-to ones (we always trust them). */
988   for ( rov = remusr; rov; rov = rov->next )
989     {
990       if ( !(rov->flags & PK_LIST_ENCRYPT_TO) )
991         {
992           /* This is a regular recipient; i.e. not an encrypt-to
993              one. */
994           any_recipients = 1;
995
996           /* Hidden recipients are not allowed while in PGP mode,
997              issue a warning and switch into GnuPG mode. */
998           if ((rov->flags & PK_LIST_HIDDEN) && (PGP6 || PGP7 || PGP8))
999             {
1000               log_info(_("you may not use %s while in %s mode\n"),
1001                        "--hidden-recipient",
1002                        compliance_option_string());
1003
1004               compliance_failure();
1005             }
1006         }
1007       else if (!opt.no_encrypt_to)
1008         {
1009           /* --encrypt-to has not been disabled.  Check this
1010              encrypt-to key. */
1011           pk = xmalloc_clear( sizeof *pk );
1012           pk->req_usage = PUBKEY_USAGE_ENC;
1013
1014           /* We explicitly allow encrypt-to to an disabled key; thus
1015              we pass 1 for the second last argument and 1 as the last
1016              argument to disable AKL. */
1017           if ( (rc = get_pubkey_byname (ctrl,
1018                                         NULL, pk, rov->d, NULL, NULL, 1, 1)) )
1019             {
1020               free_public_key ( pk ); pk = NULL;
1021               log_error (_("%s: skipped: %s\n"), rov->d, gpg_strerror (rc) );
1022               send_status_inv_recp (0, rov->d);
1023               goto fail;
1024             }
1025           else if ( !(rc=openpgp_pk_test_algo2 (pk->pubkey_algo,
1026                                                 PUBKEY_USAGE_ENC)) )
1027             {
1028               /* Skip the actual key if the key is already present
1029                * in the list.  Add it to our list if not. */
1030               if (key_present_in_pk_list(pk_list, pk) == 0)
1031                 {
1032                   free_public_key (pk); pk = NULL;
1033                   if (!opt.quiet)
1034                     log_info (_("%s: skipped: public key already present\n"),
1035                               rov->d);
1036                 }
1037               else
1038                 {
1039                   PK_LIST r;
1040                   r = xmalloc( sizeof *r );
1041                   r->pk = pk; pk = NULL;
1042                   r->next = pk_list;
1043                   r->flags = (rov->flags&PK_LIST_HIDDEN)?1:0;
1044                   pk_list = r;
1045
1046                   /* Hidden encrypt-to recipients are not allowed while
1047                      in PGP mode, issue a warning and switch into
1048                      GnuPG mode. */
1049                   if ((r->flags&PK_LIST_ENCRYPT_TO) && (PGP6 || PGP7 || PGP8))
1050                     {
1051                       log_info(_("you may not use %s while in %s mode\n"),
1052                                "--hidden-encrypt-to",
1053                                compliance_option_string());
1054
1055                       compliance_failure();
1056                     }
1057                 }
1058             }
1059           else
1060             {
1061               /* The public key is not usable for encryption. */
1062               free_public_key( pk ); pk = NULL;
1063               log_error(_("%s: skipped: %s\n"), rov->d, gpg_strerror (rc) );
1064               send_status_inv_recp (3, rov->d); /* Wrong key usage */
1065               goto fail;
1066             }
1067         }
1068     }
1069
1070   /* If we don't have any recipients yet and we are not in batch mode
1071      drop into interactive selection mode. */
1072   if ( !any_recipients && !opt.batch )
1073     {
1074       int have_def_rec;
1075       char *answer = NULL;
1076       strlist_t backlog = NULL;
1077
1078       if (pk_list)
1079         any_recipients = 1;
1080       def_rec = default_recipient(ctrl);
1081       have_def_rec = !!def_rec;
1082       if ( !have_def_rec )
1083         tty_printf(_("You did not specify a user ID. (you may use \"-r\")\n"));
1084
1085       for (;;)
1086         {
1087           rc = 0;
1088           xfree(answer);
1089           if ( have_def_rec )
1090             {
1091               /* A default recipient is taken as the first entry. */
1092               answer = def_rec;
1093               def_rec = NULL;
1094             }
1095           else if (backlog)
1096             {
1097               /* This is part of our trick to expand and display groups. */
1098               answer = strlist_pop (&backlog);
1099             }
1100           else
1101             {
1102               /* Show the list of already collected recipients and ask
1103                  for more. */
1104               PK_LIST iter;
1105
1106               tty_printf("\n");
1107               tty_printf(_("Current recipients:\n"));
1108               for (iter=pk_list;iter;iter=iter->next)
1109                 {
1110                   u32 keyid[2];
1111
1112                   keyid_from_pk(iter->pk,keyid);
1113                   tty_printf ("%s/%s %s \"",
1114                               pubkey_string (iter->pk,
1115                                              pkstrbuf, sizeof pkstrbuf),
1116                               keystr(keyid),
1117                               datestr_from_pk (iter->pk));
1118
1119                   if (iter->pk->user_id)
1120                     tty_print_utf8_string(iter->pk->user_id->name,
1121                                           iter->pk->user_id->len);
1122                   else
1123                     {
1124                       size_t n;
1125                       char *p = get_user_id( keyid, &n );
1126                       tty_print_utf8_string( p, n );
1127                       xfree(p);
1128                     }
1129                   tty_printf("\"\n");
1130                 }
1131
1132               answer = cpr_get_utf8("pklist.user_id.enter",
1133                                     _("\nEnter the user ID.  "
1134                                       "End with an empty line: "));
1135               trim_spaces(answer);
1136               cpr_kill_prompt();
1137             }
1138
1139           if ( !answer || !*answer )
1140             {
1141               xfree(answer);
1142               break;  /* No more recipients entered - get out of loop. */
1143             }
1144
1145           /* Do group expand here too.  The trick here is to continue
1146              the loop if any expansion occurred.  The code above will
1147              then list all expanded keys. */
1148           if (expand_id(answer,&backlog,0))
1149             continue;
1150
1151           /* Get and check key for the current name. */
1152           free_public_key (pk);
1153           pk = xmalloc_clear( sizeof *pk );
1154           pk->req_usage = PUBKEY_USAGE_ENC;
1155           rc = get_pubkey_byname (ctrl, NULL, pk, answer, NULL, NULL, 0, 0 );
1156           if (rc)
1157             tty_printf(_("No such user ID.\n"));
1158           else if ( !(rc=openpgp_pk_test_algo2 (pk->pubkey_algo,
1159                                                 PUBKEY_USAGE_ENC)) )
1160             {
1161               if ( have_def_rec )
1162                 {
1163                   /* No validation for a default recipient. */
1164                   if (!key_present_in_pk_list(pk_list, pk))
1165                     {
1166                       free_public_key (pk);
1167                       pk = NULL;
1168                       log_info (_("skipped: public key "
1169                                   "already set as default recipient\n") );
1170                     }
1171                   else
1172                     {
1173                       PK_LIST r = xmalloc (sizeof *r);
1174                       r->pk = pk; pk = NULL;
1175                       r->next = pk_list;
1176                       r->flags = 0; /* No throwing default ids. */
1177                       pk_list = r;
1178                     }
1179                   any_recipients = 1;
1180                   continue;
1181                 }
1182               else
1183                 { /* Check validity of this key. */
1184                   int trustlevel;
1185
1186                   trustlevel = get_validity (pk, pk->user_id, NULL, 1);
1187                   if ( (trustlevel & TRUST_FLAG_DISABLED) )
1188                     {
1189                       tty_printf (_("Public key is disabled.\n") );
1190                     }
1191                   else if ( do_we_trust_pre (pk, trustlevel) )
1192                     {
1193                       /* Skip the actual key if the key is already
1194                        * present in the list */
1195                       if (!key_present_in_pk_list(pk_list, pk))
1196                         {
1197                           free_public_key (pk);
1198                           pk = NULL;
1199                           log_info(_("skipped: public key already set\n") );
1200                         }
1201                       else
1202                         {
1203                           PK_LIST r;
1204                           r = xmalloc( sizeof *r );
1205                           r->pk = pk; pk = NULL;
1206                           r->next = pk_list;
1207                           r->flags = 0; /* No throwing interactive ids. */
1208                           pk_list = r;
1209                         }
1210                       any_recipients = 1;
1211                       continue;
1212                     }
1213                 }
1214             }
1215           xfree(def_rec); def_rec = NULL;
1216           have_def_rec = 0;
1217         }
1218       if ( pk )
1219         {
1220           free_public_key( pk );
1221           pk = NULL;
1222         }
1223     }
1224   else if ( !any_recipients && (def_rec = default_recipient(ctrl)) )
1225     {
1226       /* We are in batch mode and have only a default recipient. */
1227       pk = xmalloc_clear( sizeof *pk );
1228       pk->req_usage = PUBKEY_USAGE_ENC;
1229
1230       /* The default recipient is allowed to be disabled; thus pass 1
1231          as second last argument.  We also don't want an AKL. */
1232       rc = get_pubkey_byname (ctrl, NULL, pk, def_rec, NULL, NULL, 1, 1);
1233       if (rc)
1234         log_error(_("unknown default recipient \"%s\"\n"), def_rec );
1235       else if ( !(rc=openpgp_pk_test_algo2(pk->pubkey_algo,
1236                                            PUBKEY_USAGE_ENC)) )
1237         {
1238           /* Mark any_recipients here since the default recipient
1239              would have been used if it wasn't already there.  It
1240              doesn't really matter if we got this key from the default
1241              recipient or an encrypt-to. */
1242           any_recipients = 1;
1243           if (!key_present_in_pk_list(pk_list, pk))
1244             log_info (_("skipped: public key already set "
1245                         "as default recipient\n"));
1246           else
1247             {
1248               PK_LIST r = xmalloc( sizeof *r );
1249               r->pk = pk; pk = NULL;
1250               r->next = pk_list;
1251               r->flags = 0; /* No throwing default ids. */
1252               pk_list = r;
1253             }
1254         }
1255       if ( pk )
1256         {
1257           free_public_key( pk );
1258           pk = NULL;
1259         }
1260       xfree(def_rec); def_rec = NULL;
1261     }
1262   else
1263     {
1264       /* General case: Check all keys. */
1265       any_recipients = 0;
1266       for (; remusr; remusr = remusr->next )
1267         {
1268           if ( (remusr->flags & PK_LIST_ENCRYPT_TO) )
1269             continue; /* encrypt-to keys are already handled. */
1270
1271           rc = find_and_check_key (ctrl, remusr->d, PUBKEY_USAGE_ENC,
1272                                    !!(remusr->flags&PK_LIST_HIDDEN),
1273                                    &pk_list);
1274           if (rc)
1275             goto fail;
1276           any_recipients = 1;
1277         }
1278     }
1279
1280   if ( !rc && !any_recipients )
1281     {
1282       log_error(_("no valid addressees\n"));
1283       write_status_text (STATUS_NO_RECP, "0");
1284       rc = GPG_ERR_NO_USER_ID;
1285     }
1286
1287  fail:
1288
1289   if ( rc )
1290     release_pk_list( pk_list );
1291   else
1292     *ret_pk_list = pk_list;
1293   if (opt.grouplist)
1294     free_strlist(remusr);
1295   return rc;
1296 }
1297
1298
1299 /* In pgp6 mode, disallow all ciphers except IDEA (1), 3DES (2), and
1300    CAST5 (3), all hashes except MD5 (1), SHA1 (2), and RIPEMD160 (3),
1301    and all compressions except none (0) and ZIP (1).  pgp7 and pgp8
1302    mode expands the cipher list to include AES128 (7), AES192 (8),
1303    AES256 (9), and TWOFISH (10).  pgp8 adds the SHA-256 hash (8).  For
1304    a true PGP key all of this is unneeded as they are the only items
1305    present in the preferences subpacket, but checking here covers the
1306    weird case of encrypting to a key that had preferences from a
1307    different implementation which was then used with PGP.  I am not
1308    completely comfortable with this as the right thing to do, as it
1309    slightly alters the list of what the user is supposedly requesting.
1310    It is not against the RFC however, as the preference chosen will
1311    never be one that the user didn't specify somewhere ("The
1312    implementation may use any mechanism to pick an algorithm in the
1313    intersection"), and PGP has no mechanism to fix such a broken
1314    preference list, so I'm including it. -dms */
1315
1316 int
1317 algo_available( preftype_t preftype, int algo, const union pref_hint *hint)
1318 {
1319   if( preftype == PREFTYPE_SYM )
1320     {
1321       if(PGP6 && (algo != CIPHER_ALGO_IDEA
1322                   && algo != CIPHER_ALGO_3DES
1323                   && algo != CIPHER_ALGO_CAST5))
1324         return 0;
1325
1326       if(PGP7 && (algo != CIPHER_ALGO_IDEA
1327                   && algo != CIPHER_ALGO_3DES
1328                   && algo != CIPHER_ALGO_CAST5
1329                   && algo != CIPHER_ALGO_AES
1330                   && algo != CIPHER_ALGO_AES192
1331                   && algo != CIPHER_ALGO_AES256
1332                   && algo != CIPHER_ALGO_TWOFISH))
1333         return 0;
1334
1335       /* PGP8 supports all the ciphers we do.. */
1336
1337       return algo && !openpgp_cipher_test_algo ( algo );
1338     }
1339   else if( preftype == PREFTYPE_HASH )
1340     {
1341       if (hint && hint->digest_length)
1342         {
1343           if (hint->digest_length!=20 || opt.flags.dsa2)
1344             {
1345               /* If --enable-dsa2 is set or the hash isn't 160 bits
1346                  (which implies DSA2), then we'll accept a hash that
1347                  is larger than we need.  Otherwise we won't accept
1348                  any hash that isn't exactly the right size. */
1349               if (hint->digest_length > gcry_md_get_algo_dlen (algo))
1350                 return 0;
1351             }
1352           else if (hint->digest_length != gcry_md_get_algo_dlen (algo))
1353             return 0;
1354         }
1355
1356       if((PGP6 || PGP7) && (algo != DIGEST_ALGO_MD5
1357                             && algo != DIGEST_ALGO_SHA1
1358                             && algo != DIGEST_ALGO_RMD160))
1359         return 0;
1360
1361
1362       if(PGP8 && (algo != DIGEST_ALGO_MD5
1363                   && algo != DIGEST_ALGO_SHA1
1364                   && algo != DIGEST_ALGO_RMD160
1365                   && algo != DIGEST_ALGO_SHA256))
1366         return 0;
1367
1368       return algo && !openpgp_md_test_algo (algo);
1369     }
1370   else if( preftype == PREFTYPE_ZIP )
1371     {
1372       if((PGP6 || PGP7) && (algo != COMPRESS_ALGO_NONE
1373                             && algo != COMPRESS_ALGO_ZIP))
1374         return 0;
1375
1376       /* PGP8 supports all the compression algos we do */
1377
1378       return !check_compress_algo( algo );
1379     }
1380   else
1381     return 0;
1382 }
1383
1384 /****************
1385  * Return -1 if we could not find an algorithm.
1386  */
1387 int
1388 select_algo_from_prefs(PK_LIST pk_list, int preftype,
1389                        int request, const union pref_hint *hint)
1390 {
1391   PK_LIST pkr;
1392   u32 bits[8];
1393   const prefitem_t *prefs;
1394   int result=-1,i;
1395   u16 scores[256];
1396
1397   if( !pk_list )
1398     return -1;
1399
1400   memset(bits,0xFF,sizeof(bits));
1401   memset(scores,0,sizeof(scores));
1402
1403   for( pkr = pk_list; pkr; pkr = pkr->next )
1404     {
1405       u32 mask[8];
1406       int rank=1,implicit=-1;
1407
1408       memset(mask,0,sizeof(mask));
1409
1410       switch(preftype)
1411         {
1412         case PREFTYPE_SYM:
1413           /* IDEA is implicitly there for v3 keys with v3 selfsigs if
1414              --pgp2 mode is on.  This was a 2440 thing that was
1415              dropped from 4880 but is still relevant to GPG's 1991
1416              support.  All this doesn't mean IDEA is actually
1417              available, of course. */
1418           implicit=CIPHER_ALGO_3DES;
1419
1420           break;
1421
1422         case PREFTYPE_HASH:
1423           /* While I am including this code for completeness, note
1424              that currently --pgp2 mode locks the hash at MD5, so this
1425              code will never even be called.  Even if the hash wasn't
1426              locked at MD5, we don't support sign+encrypt in --pgp2
1427              mode, and that's the only time PREFTYPE_HASH is used
1428              anyway. -dms */
1429
1430           implicit=DIGEST_ALGO_SHA1;
1431
1432           break;
1433
1434         case PREFTYPE_ZIP:
1435           /* Uncompressed is always an option. */
1436           implicit=COMPRESS_ALGO_NONE;
1437         }
1438
1439       if (pkr->pk->user_id) /* selected by user ID */
1440         prefs = pkr->pk->user_id->prefs;
1441       else
1442         prefs = pkr->pk->prefs;
1443
1444       if( prefs )
1445         {
1446           for (i=0; prefs[i].type; i++ )
1447             {
1448               if( prefs[i].type == preftype )
1449                 {
1450                   /* Make sure all scores don't add up past 0xFFFF
1451                      (and roll around) */
1452                   if(rank+scores[prefs[i].value]<=0xFFFF)
1453                     scores[prefs[i].value]+=rank;
1454                   else
1455                     scores[prefs[i].value]=0xFFFF;
1456
1457                   mask[prefs[i].value/32] |= 1<<(prefs[i].value%32);
1458
1459                   rank++;
1460
1461                   /* We saw the implicit algorithm, so we don't need
1462                      tack it on the end ourselves. */
1463                   if(implicit==prefs[i].value)
1464                     implicit=-1;
1465                 }
1466             }
1467         }
1468
1469       if(rank==1 && preftype==PREFTYPE_ZIP)
1470         {
1471           /* If the compression preferences are not present, they are
1472              assumed to be ZIP, Uncompressed (RFC4880:13.3.1) */
1473           scores[1]=1; /* ZIP is first choice */
1474           scores[0]=2; /* Uncompressed is second choice */
1475           mask[0]|=3;
1476         }
1477
1478       /* If the key didn't have the implicit algorithm listed
1479          explicitly, add it here at the tail of the list. */
1480       if(implicit>-1)
1481         {
1482           scores[implicit]+=rank;
1483           mask[implicit/32] |= 1<<(implicit%32);
1484         }
1485
1486       for(i=0;i<8;i++)
1487         bits[i]&=mask[i];
1488     }
1489
1490   /* We've now scored all of the algorithms, and the usable ones have
1491      bits set.  Let's pick the winner. */
1492
1493   /* The caller passed us a request.  Can we use it? */
1494   if(request>-1 && (bits[request/32] & (1<<(request%32))) &&
1495      algo_available(preftype,request,hint))
1496     result=request;
1497
1498   if(result==-1)
1499     {
1500       /* If we have personal prefs set, use them. */
1501       prefs=NULL;
1502       if(preftype==PREFTYPE_SYM && opt.personal_cipher_prefs)
1503         prefs=opt.personal_cipher_prefs;
1504       else if(preftype==PREFTYPE_HASH && opt.personal_digest_prefs)
1505         prefs=opt.personal_digest_prefs;
1506       else if(preftype==PREFTYPE_ZIP && opt.personal_compress_prefs)
1507         prefs=opt.personal_compress_prefs;
1508
1509       if( prefs )
1510         for(i=0; prefs[i].type; i++ )
1511           {
1512             if(bits[prefs[i].value/32] & (1<<(prefs[i].value%32))
1513                && algo_available( preftype, prefs[i].value, hint))
1514               {
1515                 result = prefs[i].value;
1516                 break;
1517               }
1518           }
1519     }
1520
1521   if(result==-1)
1522     {
1523       unsigned int best=-1;
1524
1525       /* At this point, we have not selected an algorithm due to a
1526          special request or via personal prefs.  Pick the highest
1527          ranked algorithm (i.e. the one with the lowest score). */
1528
1529       if(preftype==PREFTYPE_HASH && scores[DIGEST_ALGO_MD5])
1530         {
1531           /* "If you are building an authentication system, the recipient
1532              may specify a preferred signing algorithm. However, the
1533              signer would be foolish to use a weak algorithm simply
1534              because the recipient requests it." (RFC4880:14).  If any
1535              other hash algorithm is available, pretend that MD5 isn't.
1536              Note that if the user intentionally chose MD5 by putting it
1537              in their personal prefs, then we do what the user said (as we
1538              never reach this code). */
1539
1540           for(i=DIGEST_ALGO_MD5+1;i<256;i++)
1541             if(scores[i])
1542               {
1543                 scores[DIGEST_ALGO_MD5]=0;
1544                 break;
1545               }
1546         }
1547
1548       for(i=0;i<256;i++)
1549         {
1550           /* Note the '<' here.  This means in case of a tie, we will
1551              favor the lower algorithm number.  We have a choice
1552              between the lower number (probably an older algorithm
1553              with more time in use), or the higher number (probably a
1554              newer algorithm with less time in use).  Older is
1555              probably safer here, even though the newer algorithms
1556              tend to be "stronger". */
1557           if(scores[i] && scores[i]<best
1558              && (bits[i/32] & (1<<(i%32)))
1559              && algo_available(preftype,i,hint))
1560             {
1561               best=scores[i];
1562               result=i;
1563             }
1564         }
1565     }
1566
1567   return result;
1568 }
1569
1570 /*
1571  * Select the MDC flag from the pk_list.  We can only use MDC if all
1572  * recipients support this feature.
1573  */
1574 int
1575 select_mdc_from_pklist (PK_LIST pk_list)
1576 {
1577   PK_LIST pkr;
1578
1579   if ( !pk_list )
1580     return 0;
1581
1582   for (pkr = pk_list; pkr; pkr = pkr->next)
1583     {
1584       int mdc;
1585
1586       if (pkr->pk->user_id) /* selected by user ID */
1587         mdc = pkr->pk->user_id->flags.mdc;
1588       else
1589         mdc = pkr->pk->flags.mdc;
1590       if (!mdc)
1591         return 0;  /* At least one recipient does not support it. */
1592     }
1593   return 1; /* Can be used. */
1594 }
1595
1596
1597 /* Print a warning for all keys in PK_LIST missing the MDC feature. */
1598 void
1599 warn_missing_mdc_from_pklist (PK_LIST pk_list)
1600 {
1601   PK_LIST pkr;
1602
1603   for (pkr = pk_list; pkr; pkr = pkr->next)
1604     {
1605       int mdc;
1606
1607       if (pkr->pk->user_id) /* selected by user ID */
1608         mdc = pkr->pk->user_id->flags.mdc;
1609       else
1610         mdc = pkr->pk->flags.mdc;
1611       if (!mdc)
1612         log_info (_("Note: key %s has no %s feature\n"),
1613                   keystr_from_pk (pkr->pk), "MDC");
1614     }
1615 }
1616
1617 void
1618 warn_missing_aes_from_pklist (PK_LIST pk_list)
1619 {
1620   PK_LIST pkr;
1621
1622   for (pkr = pk_list; pkr; pkr = pkr->next)
1623     {
1624       const prefitem_t *prefs;
1625       int i;
1626       int gotit = 0;
1627
1628       prefs = pkr->pk->user_id? pkr->pk->user_id->prefs : pkr->pk->prefs;
1629       if (prefs)
1630         {
1631           for (i=0; !gotit && prefs[i].type; i++ )
1632             if (prefs[i].type == PREFTYPE_SYM
1633                 && prefs[i].value == CIPHER_ALGO_AES)
1634               gotit++;
1635         }
1636       if (!gotit)
1637         log_info (_("Note: key %s has no preference for %s\n"),
1638                   keystr_from_pk (pkr->pk), "AES");
1639     }
1640 }