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