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