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