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