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