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