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