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