Fix spelling: "occured" should be "occurred"
[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,
826                                             (rc == G10ERR_NO_PUBKEY
827                                              || rc == G10ERR_NO_SECKEY)? "1 ":
828                                             (rc == G10ERR_INV_USER_ID)? "14 ":
829                                             "0 ",
830                                             rov->d, strlen (rov->d), -1);
831               goto fail;
832             }
833           else if ( !(rc=check_pubkey_algo2 (pk->pubkey_algo, use )) )
834             {
835               /* Skip the actual key if the key is already present
836                * in the list.  Add it to our list if not. */
837               if (key_present_in_pk_list(pk_list, pk) == 0)
838                 {
839                   free_public_key (pk); pk = NULL;
840                   if (!opt.quiet)
841                     log_info (_("%s: skipped: public key already present\n"),
842                               rov->d);
843                 }
844               else
845                 {
846                   PK_LIST r;
847                   r = xmalloc( sizeof *r );
848                   r->pk = pk; pk = NULL;
849                   r->next = pk_list;
850                   r->flags = (rov->flags&2)?1:0;
851                   pk_list = r;
852
853                   /* Hidden encrypt-to recipients are not allowed while
854                      in PGP mode, issue a warning and switch into
855                      GnuPG mode. */
856                   if ((r->flags&1) && (PGP2 || PGP6 || PGP7 || PGP8))
857                     {
858                       log_info(_("you may not use %s while in %s mode\n"),
859                                "--hidden-encrypt-to",
860                                compliance_option_string());
861
862                       compliance_failure();
863                     }
864                 }
865             }
866           else
867             {
868               /* The public key is not usable for encryption or not
869                  available. */
870               free_public_key( pk ); pk = NULL;
871               log_error(_("%s: skipped: %s\n"), rov->d, g10_errstr(rc) );
872               write_status_text_and_buffer (STATUS_INV_RECP, "3 ",
873                                             rov->d, strlen (rov->d), -1);
874               goto fail;
875             }
876         }
877     }
878
879   /* If we don't have any recipients yet and we are not in batch mode
880      drop into interactive selection mode. */
881   if ( !any_recipients && !opt.batch )
882     {
883       int have_def_rec;
884       char *answer = NULL;
885       STRLIST backlog = NULL;
886
887       if (pk_list)
888         any_recipients = 1;
889       def_rec = default_recipient();
890       have_def_rec = !!def_rec;
891       if ( !have_def_rec )
892         tty_printf(_("You did not specify a user ID. (you may use \"-r\")\n"));
893
894       for (;;)
895         {
896           rc = 0;
897           xfree(answer);
898           if ( have_def_rec )
899             {
900               /* A default recipient is taken as the first entry. */
901               answer = def_rec;
902               def_rec = NULL;
903             }
904           else if (backlog)
905             {
906               /* This is part of our trick to expand and display groups. */
907               answer = pop_strlist (&backlog);
908             }
909           else
910             {
911               /* Show the list of already collected recipients and ask
912                  for more. */
913               PK_LIST iter;
914
915               tty_printf("\n");
916               tty_printf(_("Current recipients:\n"));
917               for (iter=pk_list;iter;iter=iter->next)
918                 {
919                   u32 keyid[2];
920
921                   keyid_from_pk(iter->pk,keyid);
922                   tty_printf("%4u%c/%s %s \"",
923                              nbits_from_pk(iter->pk),
924                              pubkey_letter(iter->pk->pubkey_algo),
925                              keystr(keyid),
926                              datestr_from_pk(iter->pk));
927
928                   if (iter->pk->user_id)
929                     tty_print_utf8_string(iter->pk->user_id->name,
930                                           iter->pk->user_id->len);
931                   else
932                     {
933                       size_t n;
934                       char *p = get_user_id( keyid, &n );
935                       tty_print_utf8_string( p, n );
936                       xfree(p);
937                     }
938                   tty_printf("\"\n");
939                 }
940
941               answer = cpr_get_utf8("pklist.user_id.enter",
942                                     _("\nEnter the user ID.  "
943                                       "End with an empty line: "));
944               trim_spaces(answer);
945               cpr_kill_prompt();
946             }
947
948           if ( !answer || !*answer )
949             {
950               xfree(answer);
951               break;  /* No more recipients entered - get out of loop. */
952             }
953
954           /* Do group expand here too.  The trick here is to continue
955              the loop if any expansion occurred.  The code above will
956              then list all expanded keys. */
957           if (expand_id(answer,&backlog,0))
958             continue;
959
960           /* Get and check key for the current name. */
961           if (pk)
962             free_public_key (pk);
963           pk = xmalloc_clear( sizeof *pk );
964           pk->req_usage = use;
965           rc = get_pubkey_byname( pk, answer, NULL, NULL, 0 );
966           if (rc)
967             tty_printf(_("No such user ID.\n"));
968           else if ( !(rc=check_pubkey_algo2(pk->pubkey_algo, use)) )
969             {
970               if ( have_def_rec )
971                 {
972                   /* No validation for a default recipient. */
973                   if (!key_present_in_pk_list(pk_list, pk))
974                     {
975                       free_public_key (pk); pk = NULL;
976                       log_info (_("skipped: public key "
977                                   "already set as default recipient\n") );
978                     }
979                   else
980                     {
981                       PK_LIST r = xmalloc (sizeof *r);
982                       r->pk = pk; pk = NULL;
983                       r->next = pk_list;
984                       r->flags = 0; /* No throwing default ids. */
985                       pk_list = r;
986                     }
987                   any_recipients = 1;
988                   continue;
989                 }
990               else
991                 { /* Check validity of this key. */
992                   int trustlevel;
993
994                   trustlevel = get_validity (pk, pk->user_id);
995                   if ( (trustlevel & TRUST_FLAG_DISABLED) )
996                     {
997                       tty_printf (_("Public key is disabled.\n") );
998                     }
999                   else if ( do_we_trust_pre (pk, trustlevel) )
1000                     {
1001                       /* Skip the actual key if the key is already
1002                        * present in the list */
1003                       if (!key_present_in_pk_list(pk_list, pk))
1004                         {
1005                           free_public_key(pk); pk = NULL;
1006                           log_info(_("skipped: public key already set\n") );
1007                         }
1008                       else
1009                         {
1010                           PK_LIST r;
1011                           r = xmalloc( sizeof *r );
1012                           r->pk = pk; pk = NULL;
1013                           r->next = pk_list;
1014                           r->flags = 0; /* No throwing interactive ids. */
1015                           pk_list = r;
1016                         }
1017                       any_recipients = 1;
1018                       continue;
1019                     }
1020                 }
1021             }
1022           xfree(def_rec); def_rec = NULL;
1023           have_def_rec = 0;
1024         }
1025       if ( pk )
1026         {
1027           free_public_key( pk );
1028           pk = NULL;
1029         }
1030     }
1031   else if ( !any_recipients && (def_rec = default_recipient()) )
1032     {
1033       /* We are in batch mode and have only a default recipient. */
1034       pk = xmalloc_clear( sizeof *pk );
1035       pk->req_usage = use;
1036
1037       /* The default recipient is allowed to be disabled; thus pass 1
1038          as last argument. */
1039       rc = get_pubkey_byname (pk, def_rec, NULL, NULL, 1);
1040       if (rc)
1041         log_error(_("unknown default recipient \"%s\"\n"), def_rec );
1042       else if ( !(rc=check_pubkey_algo2(pk->pubkey_algo, use)) )
1043         {
1044           /* Mark any_recipients here since the default recipient
1045              would have been used if it wasn't already there.  It
1046              doesn't really matter if we got this key from the default
1047              recipient or an encrypt-to. */
1048           any_recipients = 1;
1049           if (!key_present_in_pk_list(pk_list, pk))
1050             log_info (_("skipped: public key already set "
1051                         "as default recipient\n"));
1052           else
1053             {
1054               PK_LIST r = xmalloc( sizeof *r );
1055               r->pk = pk; pk = NULL;
1056               r->next = pk_list;
1057               r->flags = 0; /* No throwing default ids. */
1058               pk_list = r;
1059             }
1060         }
1061       if ( pk )
1062         {
1063           free_public_key( pk );
1064           pk = NULL;
1065         }
1066       xfree(def_rec); def_rec = NULL;
1067     }
1068   else
1069     {
1070       /* General case: Check all keys. */
1071       any_recipients = 0;
1072       for (; remusr; remusr = remusr->next )
1073         {
1074           if ( (remusr->flags & 1) )
1075             continue; /* encrypt-to keys are already handled. */
1076
1077           pk = xmalloc_clear( sizeof *pk );
1078           pk->req_usage = use;
1079           if ( (rc = get_pubkey_byname( pk, remusr->d, NULL, NULL, 0 )) )
1080             {
1081               /* Key not found or other error. */
1082               free_public_key( pk ); pk = NULL;
1083               log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
1084               write_status_text_and_buffer (STATUS_INV_RECP,
1085                                             (rc == G10ERR_NO_PUBKEY
1086                                              || rc == G10ERR_NO_SECKEY)? "1 ":
1087                                             (rc == G10ERR_INV_USER_ID)? "14 ":
1088                                             "0 ",
1089                                             remusr->d, strlen (remusr->d),
1090                                             -1);
1091               goto fail;
1092             }
1093           else if ( !(rc=check_pubkey_algo2(pk->pubkey_algo, use )) )
1094             {
1095               /* Key found and usable.  Check validity. */
1096               int trustlevel;
1097
1098               trustlevel = get_validity (pk, pk->user_id);
1099               if ( (trustlevel & TRUST_FLAG_DISABLED) )
1100                 {
1101                   /*Key has been disabled. */
1102                   free_public_key(pk); pk = NULL;
1103                   log_info(_("%s: skipped: public key is disabled\n"),
1104                            remusr->d);
1105                   write_status_text_and_buffer (STATUS_INV_RECP, "13 ",
1106                                                 remusr->d,
1107                                                 strlen (remusr->d),
1108                                                 -1);
1109                   rc=G10ERR_UNU_PUBKEY;
1110                   goto fail;
1111                 }
1112               else if ( do_we_trust_pre( pk, trustlevel ) )
1113                 {
1114                   /* Note: do_we_trust may have changed the trustlevel */
1115
1116                   /* We have at least one valid recipient. It doesn't
1117                    * matters if this recipient is already present. */
1118                   any_recipients = 1;
1119
1120                   /* Skip the actual key if the key is already present
1121                    * in the list */
1122                   if (!key_present_in_pk_list(pk_list, pk))
1123                     {
1124                       free_public_key(pk); pk = NULL;
1125                       if (!opt.quiet)
1126                         log_info(_("%s: skipped: public key already present\n"),
1127                                  remusr->d);
1128                     }
1129                   else
1130                     {
1131                       PK_LIST r;
1132                       r = xmalloc( sizeof *r );
1133                       r->pk = pk; pk = NULL;
1134                       r->next = pk_list;
1135                       r->flags = (remusr->flags&2)?1:0;
1136                       pk_list = r;
1137                     }
1138                 }
1139               else
1140                 { /* We don't trust this key. */
1141                   free_public_key( pk ); pk = NULL;
1142                   write_status_text_and_buffer (STATUS_INV_RECP, "10 ",
1143                                                 remusr->d,
1144                                                 strlen (remusr->d),
1145                                                 -1);
1146                   rc=G10ERR_UNU_PUBKEY;
1147                   goto fail;
1148                 }
1149             }
1150           else
1151             {
1152               /* Key found but not usable for us (e.g. sign-only key). */
1153               free_public_key( pk ); pk = NULL;
1154               write_status_text_and_buffer (STATUS_INV_RECP, "3 ",
1155                                             remusr->d,
1156                                             strlen (remusr->d),
1157                                             -1);
1158               log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
1159               goto fail;
1160             }
1161         }
1162     }
1163
1164   if ( !rc && !any_recipients )
1165     {
1166       log_error(_("no valid addressees\n"));
1167       write_status_text (STATUS_NO_RECP, "0");
1168       rc = G10ERR_NO_USER_ID;
1169     }
1170
1171  fail:
1172
1173   if ( rc )
1174     release_pk_list( pk_list );
1175   else
1176     *ret_pk_list = pk_list;
1177   if (opt.grouplist)
1178     free_strlist(remusr);
1179   return rc;
1180 }
1181
1182
1183 /* In pgp6 mode, disallow all ciphers except IDEA (1), 3DES (2), and
1184    CAST5 (3), all hashes except MD5 (1), SHA1 (2), and RIPEMD160 (3),
1185    and all compressions except none (0) and ZIP (1).  pgp7 and pgp8
1186    mode expands the cipher list to include AES128 (7), AES192 (8),
1187    AES256 (9), and TWOFISH (10).  pgp8 adds the SHA-256 hash (8).  For
1188    a true PGP key all of this is unneeded as they are the only items
1189    present in the preferences subpacket, but checking here covers the
1190    weird case of encrypting to a key that had preferences from a
1191    different implementation which was then used with PGP.  I am not
1192    completely comfortable with this as the right thing to do, as it
1193    slightly alters the list of what the user is supposedly requesting.
1194    It is not against the RFC however, as the preference chosen will
1195    never be one that the user didn't specify somewhere ("The
1196    implementation may use any mechanism to pick an algorithm in the
1197    intersection"), and PGP has no mechanism to fix such a broken
1198    preference list, so I'm including it. -dms */
1199
1200 int
1201 algo_available( preftype_t preftype, int algo, const union pref_hint *hint )
1202 {
1203   if( preftype == PREFTYPE_SYM )
1204     {
1205       if(PGP6 && (algo != CIPHER_ALGO_IDEA
1206                   && algo != CIPHER_ALGO_3DES
1207                   && algo != CIPHER_ALGO_CAST5))
1208         return 0;
1209
1210       if(PGP7 && (algo != CIPHER_ALGO_IDEA
1211                   && algo != CIPHER_ALGO_3DES
1212                   && algo != CIPHER_ALGO_CAST5
1213                   && algo != CIPHER_ALGO_AES
1214                   && algo != CIPHER_ALGO_AES192
1215                   && algo != CIPHER_ALGO_AES256
1216                   && algo != CIPHER_ALGO_TWOFISH))
1217         return 0;
1218
1219       /* PGP8 supports all the ciphers we do.. */
1220
1221       return algo && !check_cipher_algo( algo );
1222     }
1223   else if( preftype == PREFTYPE_HASH )
1224     {
1225       if(hint && hint->digest_length)
1226         {
1227           if(hint->digest_length!=20 || opt.flags.dsa2)
1228             {
1229               /* If --enable-dsa2 is set or the hash isn't 160 bits
1230                  (which implies DSA2), then we'll accept a hash that
1231                  is larger than we need.  Otherwise we won't accept
1232                  any hash that isn't exactly the right size. */
1233               if(hint->digest_length > md_digest_length(algo))
1234                 return 0;
1235             }
1236           else if(hint->digest_length != md_digest_length(algo))
1237             return 0;
1238         }
1239
1240       if((PGP6 || PGP7) && (algo != DIGEST_ALGO_MD5
1241                             && algo != DIGEST_ALGO_SHA1
1242                             && algo != DIGEST_ALGO_RMD160))
1243         return 0;
1244
1245
1246       if(PGP8 && (algo != DIGEST_ALGO_MD5
1247                   && algo != DIGEST_ALGO_SHA1
1248                   && algo != DIGEST_ALGO_RMD160
1249                   && algo != DIGEST_ALGO_SHA256))
1250         return 0;
1251
1252       return algo && !check_digest_algo( algo );
1253     }
1254   else if( preftype == PREFTYPE_ZIP )
1255     {
1256       if((PGP6 || PGP7) && (algo != COMPRESS_ALGO_NONE
1257                             && algo != COMPRESS_ALGO_ZIP))
1258         return 0;
1259
1260       /* PGP8 supports all the compression algos we do */
1261
1262       return !check_compress_algo( algo );
1263     }
1264   else
1265     return 0;
1266 }
1267
1268 /****************
1269  * Return -1 if we could not find an algorithm.
1270  */
1271 int
1272 select_algo_from_prefs(PK_LIST pk_list, int preftype,
1273                        int request, const union pref_hint *hint)
1274 {
1275   PK_LIST pkr;
1276   u32 bits[8];
1277   const prefitem_t *prefs;
1278   int result=-1,i;
1279   u16 scores[256];
1280
1281   if( !pk_list )
1282     return -1;
1283
1284   memset(bits,0xFF,sizeof(bits));
1285   memset(scores,0,sizeof(scores));
1286
1287   for( pkr = pk_list; pkr; pkr = pkr->next )
1288     {
1289       u32 mask[8];
1290       int rank=1,implicit=-1;
1291
1292       memset(mask,0,sizeof(mask));
1293
1294       switch(preftype)
1295         {
1296         case PREFTYPE_SYM:
1297           /* IDEA is implicitly there for v3 keys with v3 selfsigs if
1298              --pgp2 mode is on.  This was a 2440 thing that was
1299              dropped from 4880 but is still relevant to GPG's 1991
1300              support.  */
1301           if(PGP2 && pkr->pk->version<4 && pkr->pk->selfsigversion<4)
1302             implicit=CIPHER_ALGO_IDEA;
1303           else
1304             implicit=CIPHER_ALGO_3DES;
1305
1306           break;
1307
1308         case PREFTYPE_HASH:
1309           /* While I am including this code for completeness, note
1310              that currently --pgp2 mode locks the hash at MD5, so this
1311              code will never even be called.  Even if the hash wasn't
1312              locked at MD5, we don't support sign+encrypt in --pgp2
1313              mode, and that's the only time PREFTYPE_HASH is used
1314              anyway. -dms */
1315
1316           /* MD5 is there for v3 keys with v3 selfsigs when --pgp2 is
1317              on. */
1318           if(PGP2 && pkr->pk->version<4 && pkr->pk->selfsigversion<4)
1319             implicit=DIGEST_ALGO_MD5;
1320           else
1321             implicit=DIGEST_ALGO_SHA1;
1322
1323           break;
1324
1325         case PREFTYPE_ZIP:
1326           /* Uncompressed is always an option. */
1327           implicit=COMPRESS_ALGO_NONE;
1328         }
1329
1330       if (pkr->pk->user_id) /* selected by user ID */
1331         prefs = pkr->pk->user_id->prefs;
1332       else
1333         prefs = pkr->pk->prefs;
1334
1335       if( prefs )
1336         {
1337           for (i=0; prefs[i].type; i++ )
1338             {
1339               if( prefs[i].type == preftype )
1340                 {
1341                   /* Make sure all scores don't add up past 0xFFFF
1342                      (and roll around) */
1343                   if(rank+scores[prefs[i].value]<=0xFFFF)
1344                     scores[prefs[i].value]+=rank;
1345                   else
1346                     scores[prefs[i].value]=0xFFFF;
1347
1348                   mask[prefs[i].value/32] |= 1<<(prefs[i].value%32);
1349
1350                   rank++;
1351
1352                   /* We saw the implicit algorithm, so we don't need
1353                      tack it on the end ourselves. */
1354                   if(implicit==prefs[i].value)
1355                     implicit=-1;
1356                 }
1357             }
1358         }
1359
1360       if(rank==1 && preftype==PREFTYPE_ZIP)
1361         {
1362           /* If the compression preferences are not present, they are
1363              assumed to be ZIP, Uncompressed (RFC4880:13.3.1) */
1364           scores[1]=1; /* ZIP is first choice */
1365           scores[0]=2; /* Uncompressed is second choice */
1366           mask[0]|=3;
1367         }
1368
1369       /* If the key didn't have the implicit algorithm listed
1370          explicitly, add it here at the tail of the list. */
1371       if(implicit>-1)
1372         {
1373           scores[implicit]+=rank;
1374           mask[implicit/32] |= 1<<(implicit%32);
1375         }
1376
1377       for(i=0;i<8;i++)
1378         bits[i]&=mask[i];
1379     }
1380
1381   /* We've now scored all of the algorithms, and the usable ones have
1382      bits set.  Let's pick the winner. */
1383
1384   /* The caller passed us a request.  Can we use it? */
1385   if(request>-1 && (bits[request/32] & (1<<(request%32))) &&
1386      algo_available(preftype,request,hint))
1387     result=request;
1388
1389   if(result==-1)
1390     {
1391       /* If we have personal prefs set, use them. */
1392       prefs=NULL;
1393       if(preftype==PREFTYPE_SYM && opt.personal_cipher_prefs)
1394         prefs=opt.personal_cipher_prefs;
1395       else if(preftype==PREFTYPE_HASH && opt.personal_digest_prefs)
1396         prefs=opt.personal_digest_prefs;
1397       else if(preftype==PREFTYPE_ZIP && opt.personal_compress_prefs)
1398         prefs=opt.personal_compress_prefs;
1399
1400       if( prefs )
1401         for(i=0; prefs[i].type; i++ )
1402           {
1403             if(bits[prefs[i].value/32] & (1<<(prefs[i].value%32))
1404                && algo_available( preftype, prefs[i].value, hint))
1405               {
1406                 result = prefs[i].value;
1407                 break;
1408               }
1409           }
1410     }
1411
1412   if(result==-1)
1413     {
1414       unsigned int best=-1;
1415
1416       /* At this point, we have not selected an algorithm due to a
1417          special request or via personal prefs.  Pick the highest
1418          ranked algorithm (i.e. the one with the lowest score). */
1419
1420       if(preftype==PREFTYPE_HASH && scores[DIGEST_ALGO_MD5])
1421         {
1422           /* "If you are building an authentication system, the recipient
1423              may specify a preferred signing algorithm. However, the
1424              signer would be foolish to use a weak algorithm simply
1425              because the recipient requests it." (RFC4880:14).  If any
1426              other hash algorithm is available, pretend that MD5 isn't.
1427              Note that if the user intentionally chose MD5 by putting it
1428              in their personal prefs, then we do what the user said (as we
1429              never reach this code). */
1430
1431           for(i=DIGEST_ALGO_MD5+1;i<256;i++)
1432             if(scores[i])
1433               {
1434                 scores[DIGEST_ALGO_MD5]=0;
1435                 break;
1436               }
1437         }
1438
1439       for(i=0;i<256;i++)
1440         {
1441           /* Note the '<' here.  This means in case of a tie, we will
1442              favor the lower algorithm number.  We have a choice
1443              between the lower number (probably an older algorithm
1444              with more time in use), or the higher number (probably a
1445              newer algorithm with less time in use).  Older is
1446              probably safer here, even though the newer algorithms
1447              tend to be "stronger". */
1448           if(scores[i] && scores[i]<best
1449              && (bits[i/32] & (1<<(i%32)))
1450              && algo_available(preftype,i,hint))
1451             {
1452               best=scores[i];
1453               result=i;
1454             }
1455         }
1456     }
1457
1458   return result;
1459 }
1460
1461 /*
1462  * Select the MDC flag from the pk_list.  We can only use MDC if all recipients
1463  * support this feature
1464  */
1465 int
1466 select_mdc_from_pklist (PK_LIST pk_list)
1467 {
1468     PK_LIST pkr;
1469
1470     if( !pk_list )
1471         return 0;
1472
1473     for (pkr = pk_list; pkr; pkr = pkr->next) {
1474         int mdc;
1475
1476         if (pkr->pk->user_id) /* selected by user ID */
1477             mdc = pkr->pk->user_id->flags.mdc;
1478         else
1479             mdc = pkr->pk->mdc_feature;
1480         if (!mdc)
1481             return 0; /* at least one recipient does not support it */
1482     }
1483     return 1; /* can be used */
1484 }