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