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