Updated FSF street address and preparations for a release candidate.
[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             m_free(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     m_free(p); p = NULL;
353   }
354   m_free(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 = m_alloc_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   switch ( (trustlevel & TRUST_MASK) ) 
536     {
537     case TRUST_EXPIRED:
538       log_info(_("Note: This key has expired!\n"));
539       print_fingerprint (pk, NULL, 1);
540       break;
541         
542     default:
543       log_error ("invalid trustlevel %u returned from validation layer\n",
544                  trustlevel);
545       /* fall thru */
546     case TRUST_UNKNOWN: 
547     case TRUST_UNDEFINED:
548       write_status( STATUS_TRUST_UNDEFINED );
549       log_info(_("WARNING: This key is not certified with"
550                  " a trusted signature!\n"));
551       log_info(_("         There is no indication that the "
552                  "signature belongs to the owner.\n" ));
553       print_fingerprint (pk, NULL, 1);
554       break;
555
556     case TRUST_NEVER:
557       /* currently we won't get that status */
558       write_status( STATUS_TRUST_NEVER );
559       log_info(_("WARNING: We do NOT trust this key!\n"));
560       log_info(_("         The signature is probably a FORGERY.\n"));
561       if (opt.with_fingerprint)
562         print_fingerprint (pk, NULL, 1);
563       rc = G10ERR_BAD_SIGN;
564       break;
565
566     case TRUST_MARGINAL:
567       write_status( STATUS_TRUST_MARGINAL );
568       log_info(_("WARNING: This key is not certified with"
569                  " sufficiently trusted signatures!\n"));
570       log_info(_("         It is not certain that the"
571                  " signature belongs to the owner.\n" ));
572       print_fingerprint (pk, NULL, 1);
573       break;
574
575     case TRUST_FULLY:
576       write_status( STATUS_TRUST_FULLY );
577       if (opt.with_fingerprint)
578         print_fingerprint (pk, NULL, 1);
579       break;
580
581     case TRUST_ULTIMATE:
582       write_status( STATUS_TRUST_ULTIMATE );
583       if (opt.with_fingerprint)
584         print_fingerprint (pk, NULL, 1);
585       break;
586     }
587
588  leave:
589   free_public_key( pk );
590   return rc;
591 }
592
593
594 void
595 release_pk_list( PK_LIST pk_list )
596 {
597     PK_LIST pk_rover;
598
599     for( ; pk_list; pk_list = pk_rover ) {
600         pk_rover = pk_list->next;
601         free_public_key( pk_list->pk );
602         m_free( pk_list );
603     }
604 }
605
606
607 static int
608 key_present_in_pk_list(PK_LIST pk_list, PKT_public_key *pk)
609 {
610     for( ; pk_list; pk_list = pk_list->next)
611         if (cmp_public_keys(pk_list->pk, pk) == 0)
612             return 0;
613
614     return -1;
615 }
616
617
618 /****************
619  * Return a malloced string with a default reciepient if there is any
620  */
621 static char *
622 default_recipient(void)
623 {
624     PKT_secret_key *sk;
625     byte fpr[MAX_FINGERPRINT_LEN+1];
626     size_t n;
627     char *p;
628     int i;
629
630     if( opt.def_recipient )
631         return m_strdup( opt.def_recipient );
632     if( !opt.def_recipient_self )
633         return NULL;
634     sk = m_alloc_clear( sizeof *sk );
635     i = get_seckey_byname( sk, NULL, 0 );
636     if( i ) {
637         free_secret_key( sk );
638         return NULL;
639     }
640     n = MAX_FINGERPRINT_LEN;
641     fingerprint_from_sk( sk, fpr, &n );
642     free_secret_key( sk );
643     p = m_alloc( 2*n+3 );
644     *p++ = '0';
645     *p++ = 'x';
646     for(i=0; i < n; i++ )
647         sprintf( p+2*i, "%02X", fpr[i] );
648     p -= 2;
649     return p;
650 }
651
652 static int
653 expand_id(const char *id,STRLIST *into,unsigned int flags)
654 {
655   struct groupitem *groups;
656   int count=0;
657
658   for(groups=opt.grouplist;groups;groups=groups->next)
659     {
660       /* need strcasecmp() here, as this should be localized */
661       if(strcasecmp(groups->name,id)==0)
662         {
663           STRLIST each,sl;
664
665           /* this maintains the current utf8-ness */
666           for(each=groups->values;each;each=each->next)
667             {
668               sl=add_to_strlist(into,each->d);
669               sl->flags=flags;
670               count++;
671             }
672
673           break;
674         }
675     }
676
677   return count;
678 }
679
680 /* For simplicity, and to avoid potential loops, we only expand once -
681    you can't make an alias that points to an alias. */
682 static STRLIST
683 expand_group(STRLIST input)
684 {
685   STRLIST sl,output=NULL,rover;
686
687   for(rover=input;rover;rover=rover->next)
688     if(expand_id(rover->d,&output,rover->flags)==0)
689       {
690         /* Didn't find any groups, so use the existing string */
691         sl=add_to_strlist(&output,rover->d);
692         sl->flags=rover->flags;
693       }
694
695   return output;
696 }
697
698 int
699 build_pk_list( STRLIST rcpts, PK_LIST *ret_pk_list, unsigned use )
700 {
701     PK_LIST pk_list = NULL;
702     PKT_public_key *pk=NULL;
703     int rc=0;
704     int any_recipients=0;
705     STRLIST rov,remusr;
706     char *def_rec = NULL;
707
708     if(opt.grouplist)
709       remusr=expand_group(rcpts);
710     else
711       remusr=rcpts;
712
713     /* check whether there are any recipients in the list and build the
714      * list of the encrypt-to ones (we always trust them) */
715     for( rov = remusr; rov; rov = rov->next ) {
716         if( !(rov->flags & 1) )
717           {
718             any_recipients = 1;
719
720             if((rov->flags&2) && (PGP2 || PGP6 || PGP7 || PGP8))
721               {
722                 log_info(_("you may not use %s while in %s mode\n"),
723                          "--hidden-recipient",
724                          compliance_option_string());
725
726                 compliance_failure();
727               }
728           }
729         else if( (use & PUBKEY_USAGE_ENC) && !opt.no_encrypt_to ) {
730             pk = m_alloc_clear( sizeof *pk );
731             pk->req_usage = use;
732             /* We can encrypt-to a disabled key */
733             if( (rc = get_pubkey_byname( pk, rov->d, NULL, NULL, 1 )) ) {
734                 free_public_key( pk ); pk = NULL;
735                 log_error(_("%s: skipped: %s\n"), rov->d, g10_errstr(rc) );
736                 write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
737                                               rov->d, strlen (rov->d), -1);
738                 goto fail;
739             }
740             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use )) ) {
741                 /* Skip the actual key if the key is already present
742                  * in the list */
743                 if (key_present_in_pk_list(pk_list, pk) == 0) {
744                     free_public_key(pk); pk = NULL;
745                     log_info(_("%s: skipped: public key already present\n"),
746                                                             rov->d);
747                 }
748                 else {
749                     PK_LIST r;
750                     r = m_alloc( sizeof *r );
751                     r->pk = pk; pk = NULL;
752                     r->next = pk_list;
753                     r->flags = (rov->flags&2)?1:0;
754                     pk_list = r;
755
756                     if(r->flags&1 && (PGP2 || PGP6 || PGP7 || PGP8))
757                       {
758                         log_info(_("you may not use %s while in %s mode\n"),
759                                  "--hidden-encrypt-to",
760                                  compliance_option_string());
761
762                         compliance_failure();
763                       }
764                 }
765             }
766             else {
767                 free_public_key( pk ); pk = NULL;
768                 log_error(_("%s: skipped: %s\n"), rov->d, g10_errstr(rc) );
769                 write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
770                                               rov->d, strlen (rov->d), -1);
771                 goto fail;
772             }
773         }
774     }
775
776     if( !any_recipients && !opt.batch ) { /* ask */
777         int have_def_rec;
778         char *answer=NULL;
779         STRLIST backlog=NULL;
780
781         if(pk_list)
782           any_recipients = 1;
783         def_rec = default_recipient();
784         have_def_rec = !!def_rec;
785         if( !have_def_rec )
786             tty_printf(_(
787                 "You did not specify a user ID. (you may use \"-r\")\n"));
788         for(;;) {
789             rc = 0;
790             m_free(answer);
791             if( have_def_rec ) {
792                 answer = def_rec;
793                 def_rec = NULL;
794             }
795             else if(backlog) {
796               answer=pop_strlist(&backlog);
797             }
798             else
799               {
800                 PK_LIST iter;
801
802                 tty_printf("\n");
803                 tty_printf(_("Current recipients:\n"));
804                 for(iter=pk_list;iter;iter=iter->next)
805                   {
806                     u32 keyid[2];
807
808                     keyid_from_pk(iter->pk,keyid);
809                     tty_printf("%4u%c/%s %s \"",
810                                nbits_from_pk(iter->pk),
811                                pubkey_letter(iter->pk->pubkey_algo),
812                                keystr(keyid),
813                                datestr_from_pk(iter->pk));
814
815                     if(iter->pk->user_id)
816                       tty_print_utf8_string(iter->pk->user_id->name,
817                                             iter->pk->user_id->len);
818                     else
819                       {
820                         size_t n;
821                         char *p = get_user_id( keyid, &n );
822                         tty_print_utf8_string( p, n );
823                         m_free(p);
824                       }
825                     tty_printf("\"\n");
826                   }
827
828                 answer = cpr_get_utf8("pklist.user_id.enter",
829                          _("\nEnter the user ID.  End with an empty line: "));
830                 trim_spaces(answer);
831                 cpr_kill_prompt();
832               }
833             if( !answer || !*answer ) {
834                 m_free(answer);
835                 break;
836             }
837             if(expand_id(answer,&backlog,0))
838               continue;
839             if( pk )
840                 free_public_key( pk );
841             pk = m_alloc_clear( sizeof *pk );
842             pk->req_usage = use;
843             rc = get_pubkey_byname( pk, answer, NULL, NULL, 0 );
844             if( rc )
845                 tty_printf(_("No such user ID.\n"));
846             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use)) ) {
847                 if( have_def_rec ) {
848                     if (key_present_in_pk_list(pk_list, pk) == 0) {
849                         free_public_key(pk); pk = NULL;
850                         log_info(_("skipped: public key "
851                                    "already set as default recipient\n") );
852                     }
853                     else {
854                         PK_LIST r = m_alloc( sizeof *r );
855                         r->pk = pk; pk = NULL;
856                         r->next = pk_list;
857                         r->flags = 0; /* no throwing default ids */
858                         pk_list = r;
859                     }
860                     any_recipients = 1;
861                     continue;
862                 }
863                 else {
864                     int trustlevel;
865                     
866                     trustlevel = get_validity (pk, pk->user_id);
867                     if( (trustlevel & TRUST_FLAG_DISABLED) ) {
868                         tty_printf(_("Public key is disabled.\n") );
869                     }
870                     else if( do_we_trust_pre( pk, trustlevel ) ) {
871                         /* Skip the actual key if the key is already present
872                          * in the list */
873                         if (key_present_in_pk_list(pk_list, pk) == 0) {
874                             free_public_key(pk); pk = NULL;
875                             log_info(_("skipped: public key already set\n") );
876                         }
877                         else {
878                             PK_LIST r;
879                             r = m_alloc( sizeof *r );
880                             r->pk = pk; pk = NULL;
881                             r->next = pk_list;
882                             r->flags = 0; /* no throwing interactive ids */
883                             pk_list = r;
884                         }
885                         any_recipients = 1;
886                         continue;
887                     }
888                 }
889             }
890             m_free(def_rec); def_rec = NULL;
891             have_def_rec = 0;
892         }
893         if( pk ) {
894             free_public_key( pk );
895             pk = NULL;
896         }
897     }
898     else if( !any_recipients && (def_rec = default_recipient()) ) {
899         pk = m_alloc_clear( sizeof *pk );
900         pk->req_usage = use;
901         /* The default recipient may be disabled */
902         rc = get_pubkey_byname( pk, def_rec, NULL, NULL, 1 );
903         if( rc )
904             log_error(_("unknown default recipient \"%s\"\n"), def_rec );
905         else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use)) ) {
906           /* Mark any_recipients here since the default recipient
907              would have been used if it wasn't already there.  It
908              doesn't really matter if we got this key from the default
909              recipient or an encrypt-to. */
910           any_recipients = 1;
911           if (key_present_in_pk_list(pk_list, pk) == 0)
912             log_info(_("skipped: public key already set as default recipient\n"));
913           else {
914             PK_LIST r = m_alloc( sizeof *r );
915             r->pk = pk; pk = NULL;
916             r->next = pk_list;
917             r->flags = 0; /* no throwing default ids */
918             pk_list = r;
919           }
920         }
921         if( pk ) {
922             free_public_key( pk );
923             pk = NULL;
924         }
925         m_free(def_rec); def_rec = NULL;
926     }
927     else {
928         any_recipients = 0;
929         for(; remusr; remusr = remusr->next ) {
930             if( (remusr->flags & 1) )
931                 continue; /* encrypt-to keys are already handled */
932
933             pk = m_alloc_clear( sizeof *pk );
934             pk->req_usage = use;
935             if( (rc = get_pubkey_byname( pk, remusr->d, NULL, NULL, 0 )) ) {
936                 free_public_key( pk ); pk = NULL;
937                 log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
938                 write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
939                                               remusr->d, strlen (remusr->d),
940                                               -1);
941                 goto fail;
942             }
943             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use )) ) {
944                 int trustlevel;
945
946                 trustlevel = get_validity (pk, pk->user_id);
947                 if( (trustlevel & TRUST_FLAG_DISABLED) ) {
948                     free_public_key(pk); pk = NULL;
949                     log_info(_("%s: skipped: public key is disabled\n"),
950                                                                     remusr->d);
951                     write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
952                                                   remusr->d,
953                                                   strlen (remusr->d),
954                                                   -1);
955                     rc=G10ERR_UNU_PUBKEY;
956                     goto fail;
957                 }
958                 else if( do_we_trust_pre( pk, trustlevel ) ) {
959                     /* note: do_we_trust may have changed the trustlevel */
960
961                     /* We have at least one valid recipient. It doesn't matters
962                      * if this recipient is already present. */
963                     any_recipients = 1;
964
965                     /* Skip the actual key if the key is already present
966                      * in the list */
967                     if (key_present_in_pk_list(pk_list, pk) == 0) {
968                         free_public_key(pk); pk = NULL;
969                         log_info(_("%s: skipped: public key already present\n"),
970                                                                     remusr->d);
971                     }
972                     else {
973                         PK_LIST r;
974                         r = m_alloc( sizeof *r );
975                         r->pk = pk; pk = NULL;
976                         r->next = pk_list;
977                         r->flags = (remusr->flags&2)?1:0;
978                         pk_list = r;
979                     }
980                 }
981                 else { /* we don't trust this pk */
982                     free_public_key( pk ); pk = NULL;
983                     write_status_text_and_buffer (STATUS_INV_RECP, "10 ",
984                                                   remusr->d,
985                                                   strlen (remusr->d),
986                                                   -1);
987                     rc=G10ERR_UNU_PUBKEY;
988                     goto fail;
989                 }
990             }
991             else {
992                 free_public_key( pk ); pk = NULL;
993                 write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
994                                               remusr->d,
995                                               strlen (remusr->d),
996                                               -1);
997                 log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
998                 goto fail;
999             }
1000         }
1001     }
1002
1003     if( !rc && !any_recipients ) {
1004         log_error(_("no valid addressees\n"));
1005         write_status_text (STATUS_NO_RECP, "0");
1006         rc = G10ERR_NO_USER_ID;
1007     }
1008
1009  fail:
1010
1011     if( rc )
1012         release_pk_list( pk_list );
1013     else
1014         *ret_pk_list = pk_list;
1015     if(opt.grouplist)
1016       free_strlist(remusr);
1017     return rc;
1018 }
1019
1020
1021 /* In pgp6 mode, disallow all ciphers except IDEA (1), 3DES (2), and
1022    CAST5 (3), all hashes except MD5 (1), SHA1 (2), and RIPEMD160 (3),
1023    and all compressions except none (0) and ZIP (1).  pgp7 and pgp8
1024    mode expands the cipher list to include AES128 (7), AES192 (8),
1025    AES256 (9), and TWOFISH (10).  pgp8 adds the SHA-256 hash (8).  For
1026    a true PGP key all of this is unneeded as they are the only items
1027    present in the preferences subpacket, but checking here covers the
1028    weird case of encrypting to a key that had preferences from a
1029    different implementation which was then used with PGP.  I am not
1030    completely comfortable with this as the right thing to do, as it
1031    slightly alters the list of what the user is supposedly requesting.
1032    It is not against the RFC however, as the preference chosen will
1033    never be one that the user didn't specify somewhere ("The
1034    implementation may use any mechanism to pick an algorithm in the
1035    intersection"), and PGP has no mechanism to fix such a broken
1036    preference list, so I'm including it. -dms */
1037
1038 int
1039 algo_available( preftype_t preftype, int algo, void *hint )
1040 {
1041   if( preftype == PREFTYPE_SYM )
1042     {
1043       if(PGP6 && (algo != CIPHER_ALGO_IDEA
1044                   && algo != CIPHER_ALGO_3DES
1045                   && algo != CIPHER_ALGO_CAST5))
1046         return 0;
1047       
1048       if(PGP7 && (algo != CIPHER_ALGO_IDEA
1049                   && algo != CIPHER_ALGO_3DES
1050                   && algo != CIPHER_ALGO_CAST5
1051                   && algo != CIPHER_ALGO_AES
1052                   && algo != CIPHER_ALGO_AES192
1053                   && algo != CIPHER_ALGO_AES256
1054                   && algo != CIPHER_ALGO_TWOFISH))
1055         return 0;
1056
1057       /* PGP8 supports all the ciphers we do.. */
1058
1059       return algo && !check_cipher_algo( algo );
1060     }
1061   else if( preftype == PREFTYPE_HASH )
1062     {
1063       if(hint && ((*(int *)hint) != md_digest_length(algo)))
1064         return 0;
1065
1066       if((PGP6 || PGP7) && (algo != DIGEST_ALGO_MD5
1067                             && algo != DIGEST_ALGO_SHA1
1068                             && algo != DIGEST_ALGO_RMD160))
1069         return 0;
1070
1071
1072       if(PGP8 && (algo != DIGEST_ALGO_MD5
1073                   && algo != DIGEST_ALGO_SHA1
1074                   && algo != DIGEST_ALGO_RMD160
1075                   && algo != DIGEST_ALGO_SHA256))
1076         return 0;
1077
1078       return algo && !check_digest_algo( algo );
1079     }
1080   else if( preftype == PREFTYPE_ZIP )
1081     {
1082       if((PGP6 || PGP7) && (algo != COMPRESS_ALGO_NONE
1083                             && algo != COMPRESS_ALGO_ZIP))
1084         return 0;
1085
1086       /* PGP8 supports all the compression algos we do */
1087
1088       return !check_compress_algo( algo );
1089     }
1090   else
1091     return 0;
1092 }
1093
1094
1095
1096 /****************
1097  * Return -1 if we could not find an algorithm.
1098  */
1099 int
1100 select_algo_from_prefs(PK_LIST pk_list, int preftype, int request, void *hint)
1101 {
1102     PK_LIST pkr;
1103     u32 bits[8];
1104     const prefitem_t *prefs;
1105     int i, j;
1106     int compr_hack=0;
1107     int any;
1108
1109     if( !pk_list )
1110         return -1;
1111
1112     memset( bits, ~0, 8 * sizeof *bits );
1113     for( pkr = pk_list; pkr; pkr = pkr->next ) {
1114         u32 mask[8];
1115
1116         memset( mask, 0, 8 * sizeof *mask );
1117         if( preftype == PREFTYPE_SYM ) {
1118           if( PGP2 &&
1119               pkr->pk->version < 4 &&
1120               pkr->pk->selfsigversion < 4 )
1121             mask[0] |= (1<<1); /* IDEA is implicitly there for v3 keys
1122                                   with v3 selfsigs (rfc2440:12.1) if
1123                                   --pgp2 mode is on.  This doesn't
1124                                   mean it's actually available, of
1125                                   course. */
1126           else
1127             mask[0] |= (1<<2); /* 3DES is implicitly there for everyone else */
1128         }
1129         else if( preftype == PREFTYPE_HASH ) {
1130           /* While I am including this code for completeness, note
1131              that currently --pgp2 mode locks the hash at MD5, so this
1132              function will never even be called.  Even if the hash
1133              wasn't locked at MD5, we don't support sign+encrypt in
1134              --pgp2 mode, and that's the only time PREFTYPE_HASH is
1135              used anyway. -dms */
1136           if( PGP2 &&
1137               pkr->pk->version < 4 &&
1138               pkr->pk->selfsigversion < 4 )
1139             mask[0] |= (1<<1); /* MD5 is there for v3 keys with v3
1140                                   selfsigs when --pgp2 is on. */
1141           else
1142             mask[0] |= (1<<2); /* SHA1 is there for everyone else */
1143         }
1144         else if( preftype == PREFTYPE_ZIP )
1145           mask[0] |= (1<<0); /* Uncompressed is implicit */
1146
1147         if (pkr->pk->user_id) /* selected by user ID */
1148             prefs = pkr->pk->user_id->prefs;
1149         else
1150             prefs = pkr->pk->prefs;
1151
1152         any = 0;
1153         if( prefs ) {
1154             for (i=0; prefs[i].type; i++ ) {
1155                 if( prefs[i].type == preftype ) {
1156                     mask[prefs[i].value/32] |= 1 << (prefs[i].value%32);
1157                     any = 1;
1158                 }
1159             }
1160         }
1161
1162         if( (!prefs || !any) && preftype == PREFTYPE_ZIP ) {
1163             mask[0] |= 3; /* asume no_compression and old pgp */
1164             compr_hack = 1;
1165         }
1166
1167 #if 0
1168         log_debug("pref mask=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
1169                (ulong)mask[7], (ulong)mask[6], (ulong)mask[5], (ulong)mask[4],
1170              (ulong)mask[3], (ulong)mask[2], (ulong)mask[1], (ulong)mask[0]);
1171 #endif
1172         for(i=0; i < 8; i++ )
1173             bits[i] &= mask[i];
1174 #if 0
1175         log_debug("pref bits=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
1176                (ulong)bits[7], (ulong)bits[6], (ulong)bits[5], (ulong)bits[4],
1177              (ulong)bits[3], (ulong)bits[2], (ulong)bits[1], (ulong)bits[0]);
1178 #endif
1179     }
1180     /* usable algorithms are now in bits
1181      * We now use the last key from pk_list to select
1182      * the algorithm we want to use. there are no
1183      * preferences for the last key, we select the one
1184      * corresponding to first set bit.
1185      */
1186     i = -1;
1187     any = 0;
1188
1189     /* Can we use the requested algorithm? */
1190     if(request>-1 && (bits[request/32] & (1<<(request%32))) &&
1191        algo_available(preftype,request,hint))
1192       return request;
1193
1194     /* If we have personal prefs set, use them instead of the last key */
1195     if(preftype==PREFTYPE_SYM && opt.personal_cipher_prefs)
1196       prefs=opt.personal_cipher_prefs;
1197     else if(preftype==PREFTYPE_HASH && opt.personal_digest_prefs)
1198       prefs=opt.personal_digest_prefs;
1199     else if(preftype==PREFTYPE_ZIP && opt.personal_compress_prefs)
1200       prefs=opt.personal_compress_prefs;
1201
1202     if( prefs ) {
1203         for(j=0; prefs[j].type; j++ ) {
1204             if( prefs[j].type == preftype ) {
1205                 if( (bits[prefs[j].value/32] & (1<<(prefs[j].value%32))) ) {
1206                     if( algo_available( preftype, prefs[j].value, hint ) ) {
1207                         any = 1;
1208                         i = prefs[j].value;
1209                         break;
1210                     }
1211                 }
1212             }
1213         }
1214     }
1215     if( !prefs || !any ) {
1216         for(j=0; j < 256; j++ )
1217             if( (bits[j/32] & (1<<(j%32))) ) {
1218                 if( algo_available( preftype, j, hint ) ) {
1219                     i = j;
1220                     break;
1221                 }
1222             }
1223     }
1224
1225 #if 0
1226     log_debug("prefs of type %d: selected %d\n", preftype, i );
1227 #endif
1228     if( compr_hack && !i ) {
1229         /* selected no compression, but we should check whether
1230          * algorithm 1 is also available (the ordering is not relevant
1231          * in this case). */
1232         if( bits[0] & (1<<1) )
1233             i = 1; /* yep; we can use compression algo 1 */
1234     }
1235
1236     /* "If you are building an authentication system, the recipient
1237        may specify a preferred signing algorithm. However, the signer
1238        would be foolish to use a weak algorithm simply because the
1239        recipient requests it." RFC2440:13.  If we settle on MD5, and
1240        SHA1 is also available, use SHA1 instead.  Of course, if the
1241        user intentionally chose MD5 (by putting it in their personal
1242        prefs), then we should do what they say. */
1243
1244     if(preftype==PREFTYPE_HASH &&
1245        i==DIGEST_ALGO_MD5 && (bits[0] & (1<<DIGEST_ALGO_SHA1)))
1246       {
1247         i=DIGEST_ALGO_SHA1;
1248
1249         if(opt.personal_digest_prefs)
1250           for(j=0; prefs[j].type; j++ )
1251             if(opt.personal_digest_prefs[j].type==PREFTYPE_HASH &&
1252                opt.personal_digest_prefs[j].value==DIGEST_ALGO_MD5)
1253               {
1254                 i=DIGEST_ALGO_MD5;
1255                 break;
1256               }
1257       }
1258
1259     return i;
1260 }
1261
1262 /*
1263  * Select the MDC flag from the pk_list.  We can only use MDC if all recipients
1264  * support this feature 
1265  */
1266 int
1267 select_mdc_from_pklist (PK_LIST pk_list)
1268 {
1269     PK_LIST pkr;
1270
1271     if( !pk_list )
1272         return 0;
1273
1274     for (pkr = pk_list; pkr; pkr = pkr->next) {
1275         int mdc;
1276
1277         if (pkr->pk->user_id) /* selected by user ID */
1278             mdc = pkr->pk->user_id->mdc_feature;
1279         else
1280             mdc = pkr->pk->mdc_feature;
1281         if (!mdc)
1282             return 0; /* at least one recipient does not support it */
1283     }
1284     return 1; /* can be used */
1285 }