6558f0d6a37d6fdcb78a211539c851417bf3e107
[gnupg.git] / g10 / pkclist.c
1 /* pkclist.c
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
3  *               2004 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:              min_num=0; break;
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; /* yes */
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 int
748 build_pk_list( STRLIST rcpts, PK_LIST *ret_pk_list, unsigned use )
749 {
750     PK_LIST pk_list = NULL;
751     PKT_public_key *pk=NULL;
752     int rc=0;
753     int any_recipients=0;
754     STRLIST rov,remusr;
755     char *def_rec = NULL;
756
757     if(opt.grouplist)
758       remusr=expand_group(rcpts);
759     else
760       remusr=rcpts;
761
762     /* check whether there are any recipients in the list and build the
763      * list of the encrypt-to ones (we always trust them) */
764     for( rov = remusr; rov; rov = rov->next ) {
765         if( !(rov->flags & 1) )
766           {
767             any_recipients = 1;
768
769             if((rov->flags&2) && (PGP2 || PGP6 || PGP7 || PGP8))
770               {
771                 log_info(_("you may not use %s while in %s mode\n"),
772                          "--hidden-recipient",
773                          compliance_option_string());
774
775                 compliance_failure();
776               }
777           }
778         else if( (use & PUBKEY_USAGE_ENC) && !opt.no_encrypt_to ) {
779             pk = xmalloc_clear( sizeof *pk );
780             pk->req_usage = use;
781             /* We can encrypt-to a disabled key */
782             if( (rc = get_pubkey_byname( pk, rov->d, NULL, NULL, 1 )) ) {
783                 free_public_key( pk ); pk = NULL;
784                 log_error(_("%s: skipped: %s\n"), rov->d, g10_errstr(rc) );
785                 write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
786                                               rov->d, strlen (rov->d), -1);
787                 goto fail;
788             }
789             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use )) ) {
790                 /* Skip the actual key if the key is already present
791                  * in the list */
792                 if (key_present_in_pk_list(pk_list, pk) == 0) {
793                     free_public_key(pk); pk = NULL;
794                     log_info(_("%s: skipped: public key already present\n"),
795                                                             rov->d);
796                 }
797                 else {
798                     PK_LIST r;
799                     r = xmalloc( sizeof *r );
800                     r->pk = pk; pk = NULL;
801                     r->next = pk_list;
802                     r->flags = (rov->flags&2)?1:0;
803                     pk_list = r;
804
805                     if(r->flags&1 && (PGP2 || PGP6 || PGP7 || PGP8))
806                       {
807                         log_info(_("you may not use %s while in %s mode\n"),
808                                  "--hidden-encrypt-to",
809                                  compliance_option_string());
810
811                         compliance_failure();
812                       }
813                 }
814             }
815             else {
816                 free_public_key( pk ); pk = NULL;
817                 log_error(_("%s: skipped: %s\n"), rov->d, g10_errstr(rc) );
818                 write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
819                                               rov->d, strlen (rov->d), -1);
820                 goto fail;
821             }
822         }
823     }
824
825     if( !any_recipients && !opt.batch ) { /* ask */
826         int have_def_rec;
827         char *answer=NULL;
828         STRLIST backlog=NULL;
829
830         if(pk_list)
831           any_recipients = 1;
832         def_rec = default_recipient();
833         have_def_rec = !!def_rec;
834         if( !have_def_rec )
835             tty_printf(_(
836                 "You did not specify a user ID. (you may use \"-r\")\n"));
837         for(;;) {
838             rc = 0;
839             xfree(answer);
840             if( have_def_rec ) {
841                 answer = def_rec;
842                 def_rec = NULL;
843             }
844             else if(backlog) {
845               answer=pop_strlist(&backlog);
846             }
847             else
848               {
849                 PK_LIST iter;
850
851                 tty_printf("\n");
852                 tty_printf(_("Current recipients:\n"));
853                 for(iter=pk_list;iter;iter=iter->next)
854                   {
855                     u32 keyid[2];
856
857                     keyid_from_pk(iter->pk,keyid);
858                     tty_printf("%4u%c/%s %s \"",
859                                nbits_from_pk(iter->pk),
860                                pubkey_letter(iter->pk->pubkey_algo),
861                                keystr(keyid),
862                                datestr_from_pk(iter->pk));
863
864                     if(iter->pk->user_id)
865                       tty_print_utf8_string(iter->pk->user_id->name,
866                                             iter->pk->user_id->len);
867                     else
868                       {
869                         size_t n;
870                         char *p = get_user_id( keyid, &n );
871                         tty_print_utf8_string( p, n );
872                         xfree(p);
873                       }
874                     tty_printf("\"\n");
875                   }
876
877                 answer = cpr_get_utf8("pklist.user_id.enter",
878                          _("\nEnter the user ID.  End with an empty line: "));
879                 trim_spaces(answer);
880                 cpr_kill_prompt();
881               }
882             if( !answer || !*answer ) {
883                 xfree(answer);
884                 break;
885             }
886             if(expand_id(answer,&backlog,0))
887               continue;
888             if( pk )
889                 free_public_key( pk );
890             pk = xmalloc_clear( sizeof *pk );
891             pk->req_usage = use;
892             rc = get_pubkey_byname( pk, answer, NULL, NULL, 0 );
893             if( rc )
894                 tty_printf(_("No such user ID.\n"));
895             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use)) ) {
896                 if( have_def_rec ) {
897                     if (key_present_in_pk_list(pk_list, pk) == 0) {
898                         free_public_key(pk); pk = NULL;
899                         log_info(_("skipped: public key "
900                                    "already set as default recipient\n") );
901                     }
902                     else {
903                         PK_LIST r = xmalloc( sizeof *r );
904                         r->pk = pk; pk = NULL;
905                         r->next = pk_list;
906                         r->flags = 0; /* no throwing default ids */
907                         pk_list = r;
908                     }
909                     any_recipients = 1;
910                     continue;
911                 }
912                 else {
913                     int trustlevel;
914                     
915                     trustlevel = get_validity (pk, pk->user_id);
916                     if( (trustlevel & TRUST_FLAG_DISABLED) ) {
917                         tty_printf(_("Public key is disabled.\n") );
918                     }
919                     else if( do_we_trust_pre( pk, trustlevel ) ) {
920                         /* Skip the actual key if the key is already present
921                          * in the list */
922                         if (key_present_in_pk_list(pk_list, pk) == 0) {
923                             free_public_key(pk); pk = NULL;
924                             log_info(_("skipped: public key already set\n") );
925                         }
926                         else {
927                             PK_LIST r;
928                             r = xmalloc( sizeof *r );
929                             r->pk = pk; pk = NULL;
930                             r->next = pk_list;
931                             r->flags = 0; /* no throwing interactive ids */
932                             pk_list = r;
933                         }
934                         any_recipients = 1;
935                         continue;
936                     }
937                 }
938             }
939             xfree(def_rec); def_rec = NULL;
940             have_def_rec = 0;
941         }
942         if( pk ) {
943             free_public_key( pk );
944             pk = NULL;
945         }
946     }
947     else if( !any_recipients && (def_rec = default_recipient()) ) {
948         pk = xmalloc_clear( sizeof *pk );
949         pk->req_usage = use;
950         /* The default recipient may be disabled */
951         rc = get_pubkey_byname( pk, def_rec, NULL, NULL, 1 );
952         if( rc )
953             log_error(_("unknown default recipient \"%s\"\n"), def_rec );
954         else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use)) ) {
955           /* Mark any_recipients here since the default recipient
956              would have been used if it wasn't already there.  It
957              doesn't really matter if we got this key from the default
958              recipient or an encrypt-to. */
959           any_recipients = 1;
960           if (key_present_in_pk_list(pk_list, pk) == 0)
961             log_info(_("skipped: public key already set as default recipient\n"));
962           else {
963             PK_LIST r = xmalloc( sizeof *r );
964             r->pk = pk; pk = NULL;
965             r->next = pk_list;
966             r->flags = 0; /* no throwing default ids */
967             pk_list = r;
968           }
969         }
970         if( pk ) {
971             free_public_key( pk );
972             pk = NULL;
973         }
974         xfree(def_rec); def_rec = NULL;
975     }
976     else {
977         any_recipients = 0;
978         for(; remusr; remusr = remusr->next ) {
979             if( (remusr->flags & 1) )
980                 continue; /* encrypt-to keys are already handled */
981
982             pk = xmalloc_clear( sizeof *pk );
983             pk->req_usage = use;
984             if( (rc = get_pubkey_byname( pk, remusr->d, NULL, NULL, 0 )) ) {
985                 free_public_key( pk ); pk = NULL;
986                 log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
987                 write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
988                                               remusr->d, strlen (remusr->d),
989                                               -1);
990                 goto fail;
991             }
992             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use )) ) {
993                 int trustlevel;
994
995                 trustlevel = get_validity (pk, pk->user_id);
996                 if( (trustlevel & TRUST_FLAG_DISABLED) ) {
997                     free_public_key(pk); pk = NULL;
998                     log_info(_("%s: skipped: public key is disabled\n"),
999                                                                     remusr->d);
1000                     write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
1001                                                   remusr->d,
1002                                                   strlen (remusr->d),
1003                                                   -1);
1004                     rc=G10ERR_UNU_PUBKEY;
1005                     goto fail;
1006                 }
1007                 else if( do_we_trust_pre( pk, trustlevel ) ) {
1008                     /* note: do_we_trust may have changed the trustlevel */
1009
1010                     /* We have at least one valid recipient. It doesn't matters
1011                      * if this recipient is already present. */
1012                     any_recipients = 1;
1013
1014                     /* Skip the actual key if the key is already present
1015                      * in the list */
1016                     if (key_present_in_pk_list(pk_list, pk) == 0) {
1017                         free_public_key(pk); pk = NULL;
1018                         log_info(_("%s: skipped: public key already present\n"),
1019                                                                     remusr->d);
1020                     }
1021                     else {
1022                         PK_LIST r;
1023                         r = xmalloc( sizeof *r );
1024                         r->pk = pk; pk = NULL;
1025                         r->next = pk_list;
1026                         r->flags = (remusr->flags&2)?1:0;
1027                         pk_list = r;
1028                     }
1029                 }
1030                 else { /* we don't trust this pk */
1031                     free_public_key( pk ); pk = NULL;
1032                     write_status_text_and_buffer (STATUS_INV_RECP, "10 ",
1033                                                   remusr->d,
1034                                                   strlen (remusr->d),
1035                                                   -1);
1036                     rc=G10ERR_UNU_PUBKEY;
1037                     goto fail;
1038                 }
1039             }
1040             else {
1041                 free_public_key( pk ); pk = NULL;
1042                 write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
1043                                               remusr->d,
1044                                               strlen (remusr->d),
1045                                               -1);
1046                 log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
1047                 goto fail;
1048             }
1049         }
1050     }
1051
1052     if( !rc && !any_recipients ) {
1053         log_error(_("no valid addressees\n"));
1054         write_status_text (STATUS_NO_RECP, "0");
1055         rc = G10ERR_NO_USER_ID;
1056     }
1057
1058  fail:
1059
1060     if( rc )
1061         release_pk_list( pk_list );
1062     else
1063         *ret_pk_list = pk_list;
1064     if(opt.grouplist)
1065       free_strlist(remusr);
1066     return rc;
1067 }
1068
1069
1070 /* In pgp6 mode, disallow all ciphers except IDEA (1), 3DES (2), and
1071    CAST5 (3), all hashes except MD5 (1), SHA1 (2), and RIPEMD160 (3),
1072    and all compressions except none (0) and ZIP (1).  pgp7 and pgp8
1073    mode expands the cipher list to include AES128 (7), AES192 (8),
1074    AES256 (9), and TWOFISH (10).  pgp8 adds the SHA-256 hash (8).  For
1075    a true PGP key all of this is unneeded as they are the only items
1076    present in the preferences subpacket, but checking here covers the
1077    weird case of encrypting to a key that had preferences from a
1078    different implementation which was then used with PGP.  I am not
1079    completely comfortable with this as the right thing to do, as it
1080    slightly alters the list of what the user is supposedly requesting.
1081    It is not against the RFC however, as the preference chosen will
1082    never be one that the user didn't specify somewhere ("The
1083    implementation may use any mechanism to pick an algorithm in the
1084    intersection"), and PGP has no mechanism to fix such a broken
1085    preference list, so I'm including it. -dms */
1086
1087 int
1088 algo_available( preftype_t preftype, int algo, void *hint )
1089 {
1090   if( preftype == PREFTYPE_SYM )
1091     {
1092       if(PGP6 && (algo != CIPHER_ALGO_IDEA
1093                   && algo != CIPHER_ALGO_3DES
1094                   && algo != CIPHER_ALGO_CAST5))
1095         return 0;
1096       
1097       if(PGP7 && (algo != CIPHER_ALGO_IDEA
1098                   && algo != CIPHER_ALGO_3DES
1099                   && algo != CIPHER_ALGO_CAST5
1100                   && algo != CIPHER_ALGO_AES
1101                   && algo != CIPHER_ALGO_AES192
1102                   && algo != CIPHER_ALGO_AES256
1103                   && algo != CIPHER_ALGO_TWOFISH))
1104         return 0;
1105
1106       /* PGP8 supports all the ciphers we do.. */
1107
1108       return algo && !check_cipher_algo( algo );
1109     }
1110   else if( preftype == PREFTYPE_HASH )
1111     {
1112       if(hint && ((*(int *)hint) != md_digest_length(algo)))
1113         return 0;
1114
1115       if((PGP6 || PGP7) && (algo != DIGEST_ALGO_MD5
1116                             && algo != DIGEST_ALGO_SHA1
1117                             && algo != DIGEST_ALGO_RMD160))
1118         return 0;
1119
1120
1121       if(PGP8 && (algo != DIGEST_ALGO_MD5
1122                   && algo != DIGEST_ALGO_SHA1
1123                   && algo != DIGEST_ALGO_RMD160
1124                   && algo != DIGEST_ALGO_SHA256))
1125         return 0;
1126
1127       return algo && !check_digest_algo( algo );
1128     }
1129   else if( preftype == PREFTYPE_ZIP )
1130     {
1131       if((PGP6 || PGP7) && (algo != COMPRESS_ALGO_NONE
1132                             && algo != COMPRESS_ALGO_ZIP))
1133         return 0;
1134
1135       /* PGP8 supports all the compression algos we do */
1136
1137       return !check_compress_algo( algo );
1138     }
1139   else
1140     return 0;
1141 }
1142
1143
1144
1145 /****************
1146  * Return -1 if we could not find an algorithm.
1147  */
1148 int
1149 select_algo_from_prefs(PK_LIST pk_list, int preftype, int request, void *hint)
1150 {
1151     PK_LIST pkr;
1152     u32 bits[8];
1153     const prefitem_t *prefs;
1154     int i, j;
1155     int compr_hack=0;
1156     int any;
1157
1158     if( !pk_list )
1159         return -1;
1160
1161     memset( bits, ~0, 8 * sizeof *bits );
1162     for( pkr = pk_list; pkr; pkr = pkr->next ) {
1163         u32 mask[8];
1164
1165         memset( mask, 0, 8 * sizeof *mask );
1166         if( preftype == PREFTYPE_SYM ) {
1167           if( PGP2 &&
1168               pkr->pk->version < 4 &&
1169               pkr->pk->selfsigversion < 4 )
1170             mask[0] |= (1<<1); /* IDEA is implicitly there for v3 keys
1171                                   with v3 selfsigs (rfc2440:12.1) if
1172                                   --pgp2 mode is on.  This doesn't
1173                                   mean it's actually available, of
1174                                   course. */
1175           else
1176             mask[0] |= (1<<2); /* 3DES is implicitly there for everyone else */
1177         }
1178         else if( preftype == PREFTYPE_HASH ) {
1179           /* While I am including this code for completeness, note
1180              that currently --pgp2 mode locks the hash at MD5, so this
1181              function will never even be called.  Even if the hash
1182              wasn't locked at MD5, we don't support sign+encrypt in
1183              --pgp2 mode, and that's the only time PREFTYPE_HASH is
1184              used anyway. -dms */
1185           if( PGP2 &&
1186               pkr->pk->version < 4 &&
1187               pkr->pk->selfsigversion < 4 )
1188             mask[0] |= (1<<1); /* MD5 is there for v3 keys with v3
1189                                   selfsigs when --pgp2 is on. */
1190           else
1191             mask[0] |= (1<<2); /* SHA1 is there for everyone else */
1192         }
1193         else if( preftype == PREFTYPE_ZIP )
1194           mask[0] |= (1<<0); /* Uncompressed is implicit */
1195
1196         if (pkr->pk->user_id) /* selected by user ID */
1197             prefs = pkr->pk->user_id->prefs;
1198         else
1199             prefs = pkr->pk->prefs;
1200
1201         any = 0;
1202         if( prefs ) {
1203             for (i=0; prefs[i].type; i++ ) {
1204                 if( prefs[i].type == preftype ) {
1205                     mask[prefs[i].value/32] |= 1 << (prefs[i].value%32);
1206                     any = 1;
1207                 }
1208             }
1209         }
1210
1211         if( (!prefs || !any) && preftype == PREFTYPE_ZIP ) {
1212             mask[0] |= 3; /* asume no_compression and old pgp */
1213             compr_hack = 1;
1214         }
1215
1216 #if 0
1217         log_debug("pref mask=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
1218                (ulong)mask[7], (ulong)mask[6], (ulong)mask[5], (ulong)mask[4],
1219              (ulong)mask[3], (ulong)mask[2], (ulong)mask[1], (ulong)mask[0]);
1220 #endif
1221         for(i=0; i < 8; i++ )
1222             bits[i] &= mask[i];
1223 #if 0
1224         log_debug("pref bits=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
1225                (ulong)bits[7], (ulong)bits[6], (ulong)bits[5], (ulong)bits[4],
1226              (ulong)bits[3], (ulong)bits[2], (ulong)bits[1], (ulong)bits[0]);
1227 #endif
1228     }
1229     /* usable algorithms are now in bits
1230      * We now use the last key from pk_list to select
1231      * the algorithm we want to use. there are no
1232      * preferences for the last key, we select the one
1233      * corresponding to first set bit.
1234      */
1235     i = -1;
1236     any = 0;
1237
1238     /* Can we use the requested algorithm? */
1239     if(request>-1 && (bits[request/32] & (1<<(request%32))) &&
1240        algo_available(preftype,request,hint))
1241       return request;
1242
1243     /* If we have personal prefs set, use them instead of the last key */
1244     if(preftype==PREFTYPE_SYM && opt.personal_cipher_prefs)
1245       prefs=opt.personal_cipher_prefs;
1246     else if(preftype==PREFTYPE_HASH && opt.personal_digest_prefs)
1247       prefs=opt.personal_digest_prefs;
1248     else if(preftype==PREFTYPE_ZIP && opt.personal_compress_prefs)
1249       prefs=opt.personal_compress_prefs;
1250
1251     if( prefs ) {
1252         for(j=0; prefs[j].type; j++ ) {
1253             if( prefs[j].type == preftype ) {
1254                 if( (bits[prefs[j].value/32] & (1<<(prefs[j].value%32))) ) {
1255                     if( algo_available( preftype, prefs[j].value, hint ) ) {
1256                         any = 1;
1257                         i = prefs[j].value;
1258                         break;
1259                     }
1260                 }
1261             }
1262         }
1263     }
1264     if( !prefs || !any ) {
1265         for(j=0; j < 256; j++ )
1266             if( (bits[j/32] & (1<<(j%32))) ) {
1267                 if( algo_available( preftype, j, hint ) ) {
1268                     i = j;
1269                     break;
1270                 }
1271             }
1272     }
1273
1274 #if 0
1275     log_debug("prefs of type %d: selected %d\n", preftype, i );
1276 #endif
1277     if( compr_hack && !i ) {
1278         /* selected no compression, but we should check whether
1279          * algorithm 1 is also available (the ordering is not relevant
1280          * in this case). */
1281         if( bits[0] & (1<<1) )
1282             i = 1; /* yep; we can use compression algo 1 */
1283     }
1284
1285     /* "If you are building an authentication system, the recipient
1286        may specify a preferred signing algorithm. However, the signer
1287        would be foolish to use a weak algorithm simply because the
1288        recipient requests it." RFC2440:13.  If we settle on MD5, and
1289        SHA1 is also available, use SHA1 instead.  Of course, if the
1290        user intentionally chose MD5 (by putting it in their personal
1291        prefs), then we should do what they say. */
1292
1293     if(preftype==PREFTYPE_HASH &&
1294        i==DIGEST_ALGO_MD5 && (bits[0] & (1<<DIGEST_ALGO_SHA1)))
1295       {
1296         i=DIGEST_ALGO_SHA1;
1297
1298         if(opt.personal_digest_prefs)
1299           for(j=0; prefs[j].type; j++ )
1300             if(opt.personal_digest_prefs[j].type==PREFTYPE_HASH &&
1301                opt.personal_digest_prefs[j].value==DIGEST_ALGO_MD5)
1302               {
1303                 i=DIGEST_ALGO_MD5;
1304                 break;
1305               }
1306       }
1307
1308     return i;
1309 }
1310
1311 /*
1312  * Select the MDC flag from the pk_list.  We can only use MDC if all recipients
1313  * support this feature 
1314  */
1315 int
1316 select_mdc_from_pklist (PK_LIST pk_list)
1317 {
1318     PK_LIST pkr;
1319
1320     if( !pk_list )
1321         return 0;
1322
1323     for (pkr = pk_list; pkr; pkr = pkr->next) {
1324         int mdc;
1325
1326         if (pkr->pk->user_id) /* selected by user ID */
1327             mdc = pkr->pk->user_id->mdc_feature;
1328         else
1329             mdc = pkr->pk->mdc_feature;
1330         if (!mdc)
1331             return 0; /* at least one recipient does not support it */
1332     }
1333     return 1; /* can be used */
1334 }