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