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