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