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