9ed8ef3a49fb2a2f64cec2729044f4599e90b78d
[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         /* This string also used in keyedit.c:sign_uids */
310         tty_printf (_(
311                      "Please decide how far you trust this user to correctly\n"
312                      "verify other users' keys (by looking at passports,\n"
313                      "checking fingerprints from different sources...)?\n\n"));
314         if(min_num<=1)
315           tty_printf (_(" %d = I don't know\n"), 1);
316         if(min_num<=2)
317           tty_printf (_(" %d = I do NOT trust\n"), 2);
318         if(min_num<=3)
319           tty_printf (_(" %d = I trust marginally\n"), 3);
320         if(min_num<=4)
321           tty_printf (_(" %d = I trust fully\n"), 4);
322         if (mode)
323           tty_printf (_(" %d = I trust ultimately\n"), 5);
324 #if 0
325         /* not yet implemented */
326         tty_printf (_(" i = please show me more information\n") );
327 #endif
328         if( mode )
329           tty_printf(_(" m = back to the main menu\n"));
330         else
331           {
332             tty_printf(_(" s = skip this key\n"));
333             tty_printf(_(" q = quit\n"));
334           }
335         tty_printf("\n");
336         if(minimum)
337           tty_printf(_("The minimum trust level for this key is: %s\n\n"),
338                      trust_string(minimum));
339         did_help = 1;
340       }
341     if( strlen(ans) != 8 )
342       BUG();
343     p = cpr_get("edit_ownertrust.value",_("Your decision? "));
344     trim_spaces(p);
345     cpr_kill_prompt();
346     if( !*p )
347       did_help = 0;
348     else if( *p && p[1] )
349       ;
350     else if( !p[1] && ((*p >= '0'+min_num) && *p <= (mode?'5':'4')) ) 
351       {
352         unsigned int trust;
353         switch( *p )
354           {
355           case '1': trust = TRUST_UNDEFINED; break;
356           case '2': trust = TRUST_NEVER    ; break;
357           case '3': trust = TRUST_MARGINAL ; break;
358           case '4': trust = TRUST_FULLY    ; break;
359           case '5': trust = TRUST_ULTIMATE ; break;
360           default: BUG();
361           }
362         if (trust == TRUST_ULTIMATE
363             && !cpr_get_answer_is_yes ("edit_ownertrust.set_ultimate.okay",
364                                        _("Do you really want to set this key"
365                                          " to ultimate trust? ")))
366           ; /* no */
367         else
368           {
369             *new_trust = trust;
370             changed = 1;
371             break;
372           }
373       }
374 #if 0
375     /* not yet implemented */
376     else if( *p == ans[0] || *p == ans[1] ) 
377       {
378         tty_printf(_("Certificates leading to an ultimately trusted key:\n"));
379         show = 1;
380         break;
381       }
382 #endif
383     else if( mode && (*p == ans[2] || *p == ans[3] || *p == CONTROL_D ) ) 
384       {
385         break ; /* back to the menu */
386       }
387     else if( !mode && (*p == ans[6] || *p == ans[7] ) )
388       {
389         break; /* skip */
390       }
391     else if( !mode && (*p == ans[4] || *p == ans[5] ) )
392       {
393         quit = 1;
394         break ; /* back to the menu */
395       }
396     m_free(p); p = NULL;
397   }
398   m_free(p);
399   return show? -2: quit? -1 : changed;
400 }
401
402 /* 
403  * Display a menu to change the ownertrust of the key PK (which should
404  * be a primary key).  
405  * For mode values see do_edit_ownertrust ()
406  */
407 int
408 edit_ownertrust (PKT_public_key *pk, int mode )
409 {
410   unsigned int trust;
411   int no_help = 0;
412
413   for(;;)
414     {
415       switch ( do_edit_ownertrust (pk, mode, &trust, no_help ) )
416         {
417         case -1: /* quit */
418           return -1;
419         case -2: /* show info */
420           show_paths(pk, 1);
421           no_help = 1;
422           break;
423         case 1: /* trust value set */
424           trust &= ~TRUST_FLAG_DISABLED;
425           trust |= get_ownertrust (pk) & TRUST_FLAG_DISABLED;
426           update_ownertrust (pk, trust );
427           return 1;
428         default:
429           return 0;
430         }
431     }
432 }
433
434
435 /****************
436  * Check whether we can trust this pk which has a trustlevel of TRUSTLEVEL
437  * Returns: true if we trust.
438  */
439 static int
440 do_we_trust( PKT_public_key *pk, unsigned int *trustlevel )
441 {
442     unsigned int trustmask = 0;
443
444     /* FIXME: get_pubkey_byname already checks the validity and won't
445      * return keys which are either expired or revoked - so these
446      * question here won't get triggered.  We have to find a solution
447      * for this.  It might make sense to have a function in getkey.c
448      * which does only the basic checks and returns even revoked and
449      * expired keys.  This fnction could then also returhn a list of
450      * keys if the speicified name is ambiguous
451      */
452     if( (*trustlevel & TRUST_FLAG_REVOKED) ) {
453         log_info(_("key %08lX: key has been revoked!\n"),
454                                         (ulong)keyid_from_pk( pk, NULL) );
455         show_revocation_reason( pk, 0 );
456         if( opt.batch )
457           return 0; /* no */
458
459         if( !cpr_get_answer_is_yes("revoked_key.override",
460                                     _("Use this key anyway? ")) )
461           return 0; /* no */
462         trustmask |= TRUST_FLAG_REVOKED;
463     }
464     if( (*trustlevel & TRUST_FLAG_SUB_REVOKED) ) {
465         log_info(_("key %08lX: subkey has been revoked!\n"),
466                                         (ulong)keyid_from_pk( pk, NULL) );
467         show_revocation_reason( pk, 0 );
468         if( opt.batch )
469             return 0;
470
471         if( !cpr_get_answer_is_yes("revoked_key.override",
472                                     _("Use this key anyway? ")) )
473             return 0;
474         trustmask |= TRUST_FLAG_SUB_REVOKED;
475     }
476     *trustlevel &= ~trustmask;
477
478     if( opt.trust_model==TM_ALWAYS ) {
479         if( opt.verbose )
480             log_info("No trust check due to --trust-model always option\n");
481         return 1;
482     }
483
484     switch( (*trustlevel & TRUST_MASK) ) {
485       case TRUST_EXPIRED:
486         log_info(_("%08lX: key has expired\n"),
487                                     (ulong)keyid_from_pk( pk, NULL) );
488         return 0; /* no */
489
490       default:
491          log_error ("invalid trustlevel %u returned from validation layer\n",
492                     *trustlevel);
493          /* fall thru */
494       case TRUST_UNKNOWN: 
495       case TRUST_UNDEFINED:
496         log_info(_("%08lX: There is no assurance this key belongs "
497                    "to the named user\n"),(ulong)keyid_from_pk( pk, NULL) );
498         return 0; /* no */
499
500         /* No way to get here? */
501       case TRUST_NEVER:
502         log_info(_("%08lX: We do NOT trust this key\n"),
503                                         (ulong)keyid_from_pk( pk, NULL) );
504         return 0; /* no */
505
506       case TRUST_MARGINAL:
507         log_info(_("%08lX: There is limited assurance this key belongs "
508                    "to the named user\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 named user\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.trust_model==TM_ALWAYS && !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.trust_model==TM_ALWAYS )
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           {
812             any_recipients = 1;
813
814             if((rov->flags&2) && (opt.pgp2 || opt.pgp6 || opt.pgp7))
815               {
816                 log_info(_("you may not use %s while in %s mode\n"),
817                          "--hidden-recipient",
818                          opt.pgp2?"--pgp2":opt.pgp6?"--pgp6":"--pgp7");
819
820                 log_info(_("this message may not be usable by %s\n"),
821                          opt.pgp2?"PGP 2.x":opt.pgp6?"PGP 6.x":"PGP 7.x");
822
823                 opt.pgp2=opt.pgp6=opt.pgp7=0;
824               }
825           }
826         else if( (use & PUBKEY_USAGE_ENC) && !opt.no_encrypt_to ) {
827             pk = m_alloc_clear( sizeof *pk );
828             pk->req_usage = use;
829             if( (rc = get_pubkey_byname( pk, rov->d, NULL, NULL )) ) {
830                 free_public_key( pk ); pk = NULL;
831                 log_error(_("%s: skipped: %s\n"), rov->d, g10_errstr(rc) );
832                 write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
833                                               rov->d, strlen (rov->d), -1);
834                 goto fail;
835             }
836             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use )) ) {
837                 /* Skip the actual key if the key is already present
838                  * in the list */
839                 if (key_present_in_pk_list(pk_list, pk) == 0) {
840                     free_public_key(pk); pk = NULL;
841                     log_info(_("%s: skipped: public key already present\n"),
842                                                             rov->d);
843                 }
844                 else {
845                     PK_LIST r;
846                     r = m_alloc( sizeof *r );
847                     r->pk = pk; pk = NULL;
848                     r->next = pk_list;
849                     r->flags = (rov->flags&2)?1:0;
850                     pk_list = r;
851
852                     if(r->flags&1 && (opt.pgp2 || opt.pgp6 || opt.pgp7))
853                       {
854                         log_info(_("you may not use %s while in %s mode\n"),
855                                  "--hidden-encrypt-to",
856                                  opt.pgp2?"--pgp2":opt.pgp6?"--pgp6":"--pgp7");
857
858                         log_info(_("this message may not be usable by %s\n"),
859                               opt.pgp2?"PGP 2.x":opt.pgp6?"PGP 6.x":"PGP 7.x");
860
861                         opt.pgp2=opt.pgp6=opt.pgp7=0;
862                       }
863                 }
864             }
865             else {
866                 free_public_key( pk ); pk = NULL;
867                 log_error(_("%s: skipped: %s\n"), rov->d, g10_errstr(rc) );
868                 write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
869                                               rov->d, strlen (rov->d), -1);
870                 goto fail;
871             }
872         }
873     }
874
875     if( !any_recipients && !opt.batch ) { /* ask */
876         int have_def_rec;
877         char *answer=NULL;
878         STRLIST backlog=NULL;
879
880         def_rec = default_recipient();
881         have_def_rec = !!def_rec;
882         if( !have_def_rec )
883             tty_printf(_(
884                 "You did not specify a user ID. (you may use \"-r\")\n"));
885         for(;;) {
886             rc = 0;
887             m_free(answer);
888             if( have_def_rec ) {
889                 answer = def_rec;
890                 def_rec = NULL;
891             }
892             else if(backlog) {
893               answer=pop_strlist(&backlog);
894             }
895             else {
896                 answer = cpr_get_utf8("pklist.user_id.enter",
897                          _("\nEnter the user ID.  End with an empty line: "));
898                 trim_spaces(answer);
899                 cpr_kill_prompt();
900             }
901             if( !answer || !*answer ) {
902                 m_free(answer);
903                 break;
904             }
905             if(expand_id(answer,&backlog,0))
906               continue;
907             if( pk )
908                 free_public_key( pk );
909             pk = m_alloc_clear( sizeof *pk );
910             pk->req_usage = use;
911             rc = get_pubkey_byname( pk, answer, NULL, NULL );
912             if( rc )
913                 tty_printf(_("No such user ID.\n"));
914             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use)) ) {
915                 if( have_def_rec ) {
916                     if (key_present_in_pk_list(pk_list, pk) == 0) {
917                         free_public_key(pk); pk = NULL;
918                         log_info(_("skipped: public key "
919                                    "already set as default recipient\n") );
920                     }
921                     else {
922                         PK_LIST r = m_alloc( sizeof *r );
923                         r->pk = pk; pk = NULL;
924                         r->next = pk_list;
925                         r->flags = 0; /* no throwing default ids */
926                         pk_list = r;
927                     }
928                     any_recipients = 1;
929                     continue;
930                 }
931                 else {
932                     int trustlevel;
933
934                     trustlevel = get_validity (pk, NULL);
935                     if( (trustlevel & TRUST_FLAG_DISABLED) ) {
936                         tty_printf(_("Public key is disabled.\n") );
937                     }
938                     else if( do_we_trust_pre( pk, trustlevel ) ) {
939                         /* Skip the actual key if the key is already present
940                          * in the list */
941                         if (key_present_in_pk_list(pk_list, pk) == 0) {
942                             free_public_key(pk); pk = NULL;
943                             log_info(_("skipped: public key already set\n") );
944                         }
945                         else {
946                             PK_LIST r;
947                             char *p;
948                             size_t n;
949                             u32 keyid[2];
950
951                             keyid_from_pk( pk, keyid);
952                             tty_printf("Added %4u%c/%08lX %s \"",
953                                        nbits_from_pk( pk ),
954                                        pubkey_letter( pk->pubkey_algo ),
955                                        (ulong)keyid[1],
956                                        datestr_from_pk( pk ) );
957                             p = get_user_id( keyid, &n );
958                             tty_print_utf8_string( p, n );
959                             m_free(p);
960                             tty_printf("\"\n");
961
962                             r = m_alloc( sizeof *r );
963                             r->pk = pk; pk = NULL;
964                             r->next = pk_list;
965                             r->flags = 0; /* no throwing interactive ids */
966                             pk_list = r;
967                         }
968                         any_recipients = 1;
969                         continue;
970                     }
971                 }
972             }
973             m_free(def_rec); def_rec = NULL;
974             have_def_rec = 0;
975         }
976         if( pk ) {
977             free_public_key( pk );
978             pk = NULL;
979         }
980     }
981     else if( !any_recipients && (def_rec = default_recipient()) ) {
982         pk = m_alloc_clear( sizeof *pk );
983         pk->req_usage = use;
984         rc = get_pubkey_byname( pk, def_rec, NULL, NULL );
985         if( rc )
986             log_error(_("unknown default recipient `%s'\n"), def_rec );
987         else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use)) ) {
988           /* Mark any_recipients here since the default recipient
989              would have been used if it wasn't already there.  It
990              doesn't really matter if we got this key from the default
991              recipient or an encrypt-to. */
992           any_recipients = 1;
993           if (key_present_in_pk_list(pk_list, pk) == 0)
994             log_info(_("skipped: public key already set as default recipient\n"));
995           else {
996             PK_LIST r = m_alloc( sizeof *r );
997             r->pk = pk; pk = NULL;
998             r->next = pk_list;
999             r->flags = 0; /* no throwing default ids */
1000             pk_list = r;
1001           }
1002         }
1003         if( pk ) {
1004             free_public_key( pk );
1005             pk = NULL;
1006         }
1007         m_free(def_rec); def_rec = NULL;
1008     }
1009     else {
1010         any_recipients = 0;
1011         for(; remusr; remusr = remusr->next ) {
1012             if( (remusr->flags & 1) )
1013                 continue; /* encrypt-to keys are already handled */
1014
1015             pk = m_alloc_clear( sizeof *pk );
1016             pk->req_usage = use;
1017             if( (rc = get_pubkey_byname( pk, remusr->d, NULL, NULL )) ) {
1018                 free_public_key( pk ); pk = NULL;
1019                 log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
1020                 write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
1021                                               remusr->d, strlen (remusr->d),
1022                                               -1);
1023                 goto fail;
1024             }
1025             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use )) ) {
1026                 int trustlevel;
1027
1028                 trustlevel = get_validity (pk, pk->namehash);
1029                 if( (trustlevel & TRUST_FLAG_DISABLED) ) {
1030                     free_public_key(pk); pk = NULL;
1031                     log_info(_("%s: skipped: public key is disabled\n"),
1032                                                                     remusr->d);
1033                     write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
1034                                                   remusr->d,
1035                                                   strlen (remusr->d),
1036                                                   -1);
1037                     rc=G10ERR_UNU_PUBKEY;
1038                     goto fail;
1039                 }
1040                 else if( do_we_trust_pre( pk, trustlevel ) ) {
1041                     /* note: do_we_trust may have changed the trustlevel */
1042
1043                     /* We have at least one valid recipient. It doesn't matters
1044                      * if this recipient is already present. */
1045                     any_recipients = 1;
1046
1047                     /* Skip the actual key if the key is already present
1048                      * in the list */
1049                     if (key_present_in_pk_list(pk_list, pk) == 0) {
1050                         free_public_key(pk); pk = NULL;
1051                         log_info(_("%s: skipped: public key already present\n"),
1052                                                                     remusr->d);
1053                     }
1054                     else {
1055                         PK_LIST r;
1056                         r = m_alloc( sizeof *r );
1057                         r->pk = pk; pk = NULL;
1058                         r->next = pk_list;
1059                         r->flags = (remusr->flags&2)?1:0;
1060                         pk_list = r;
1061                     }
1062                 }
1063                 else { /* we don't trust this pk */
1064                     free_public_key( pk ); pk = NULL;
1065                     write_status_text_and_buffer (STATUS_INV_RECP, "10 ",
1066                                                   remusr->d,
1067                                                   strlen (remusr->d),
1068                                                   -1);
1069                     rc=G10ERR_UNU_PUBKEY;
1070                     goto fail;
1071                 }
1072             }
1073             else {
1074                 free_public_key( pk ); pk = NULL;
1075                 write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
1076                                               remusr->d,
1077                                               strlen (remusr->d),
1078                                               -1);
1079                 log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
1080                 goto fail;
1081             }
1082         }
1083     }
1084
1085     if( !rc && !any_recipients ) {
1086         log_error(_("no valid addressees\n"));
1087         write_status_text (STATUS_NO_RECP, "0");
1088         rc = G10ERR_NO_USER_ID;
1089     }
1090
1091  fail:
1092
1093     if( rc )
1094         release_pk_list( pk_list );
1095     else
1096         *ret_pk_list = pk_list;
1097     if(opt.grouplist)
1098       free_strlist(remusr);
1099     return rc;
1100 }
1101
1102
1103 /* In pgp6 mode, disallow all ciphers except IDEA (1), 3DES (2), and
1104    CAST5 (3), all hashes except MD5 (1), SHA1 (2), and RIPEMD160 (3),
1105    and all compressions except none (0) and ZIP (1).  pgp7 and pgp8
1106    mode expands the cipher list to include AES128 (7), AES192 (8),
1107    AES256 (9), and TWOFISH (10).  For a true PGP key all of this is
1108    unneeded as they are the only items present in the preferences
1109    subpacket, but checking here covers the weird case of encrypting to
1110    a key that had preferences from a different implementation which
1111    was then used with PGP.  I am not completely comfortable with this
1112    as the right thing to do, as it slightly alters the list of what
1113    the user is supposedly requesting.  It is not against the RFC
1114    however, as the preference chosen will never be one that the user
1115    didn't specify somewhere ("The implementation may use any mechanism
1116    to pick an algorithm in the intersection"), and PGP has no
1117    mechanism to fix such a broken preference list, so I'm including
1118    it. -dms */
1119
1120 static int
1121 algo_available( int preftype, int algo, void *hint )
1122 {
1123     if( preftype == PREFTYPE_SYM ) {
1124         if( opt.pgp6 && ( algo != 1 && algo != 2 && algo != 3) )
1125           return 0;
1126
1127         if( (opt.pgp7 || opt.pgp8)
1128             && (algo != 1 && algo != 2 && algo != 3
1129                 && algo != 7 && algo != 8 && algo != 9 && algo != 10) )
1130           return 0;
1131
1132         return algo && !check_cipher_algo( algo );
1133     }
1134     else if( preftype == PREFTYPE_HASH ) {
1135         int bits=0;
1136
1137         if(hint)
1138           bits=*(int *)hint;
1139
1140         if(bits && (bits != md_digest_length(algo)))
1141           return 0;
1142
1143         if( (opt.pgp6 || opt.pgp7 || opt.pgp8 )
1144             && ( algo != 1 && algo != 2 && algo != 3) )
1145           return 0;
1146
1147         return algo && !check_digest_algo( algo );
1148     }
1149     else if( preftype == PREFTYPE_ZIP ) {
1150         if ( ( opt.pgp6 || opt.pgp7 || opt.pgp8 )
1151              && ( algo !=0 && algo != 1) )
1152           return 0;
1153
1154         return !check_compress_algo( algo );
1155     }
1156     else
1157         return 0;
1158 }
1159
1160
1161
1162 /****************
1163  * Return -1 if we could not find an algorithm.
1164  */
1165 int
1166 select_algo_from_prefs(PK_LIST pk_list, int preftype, int request, void *hint)
1167 {
1168     PK_LIST pkr;
1169     u32 bits[8];
1170     const prefitem_t *prefs;
1171     int i, j;
1172     int compr_hack=0;
1173     int any;
1174
1175     if( !pk_list )
1176         return -1;
1177
1178     memset( bits, ~0, 8 * sizeof *bits );
1179     for( pkr = pk_list; pkr; pkr = pkr->next ) {
1180         u32 mask[8];
1181
1182         memset( mask, 0, 8 * sizeof *mask );
1183         if( preftype == PREFTYPE_SYM ) {
1184           if( opt.pgp2 &&
1185               pkr->pk->version < 4 &&
1186               pkr->pk->selfsigversion < 4 )
1187             mask[0] |= (1<<1); /* IDEA is implicitly there for v3 keys
1188                                   with v3 selfsigs (rfc2440:12.1) if
1189                                   --pgp2 mode is on.  This doesn't
1190                                   mean it's actually available, of
1191                                   course. */
1192           else
1193             mask[0] |= (1<<2); /* 3DES is implicitly there for everyone else */
1194         }
1195         else if( preftype == PREFTYPE_HASH ) {
1196           /* While I am including this code for completeness, note
1197              that currently --pgp2 mode locks the hash at MD5, so this
1198              function will never even be called.  Even if the hash
1199              wasn't locked at MD5, we don't support sign+encrypt in
1200              --pgp2 mode, and that's the only time PREFTYPE_HASH is
1201              used anyway. -dms */
1202           if( opt.pgp2 &&
1203               pkr->pk->version < 4 &&
1204               pkr->pk->selfsigversion < 4 )
1205             mask[0] |= (1<<1); /* MD5 is there for v3 keys with v3
1206                                   selfsigs when --pgp2 is on. */
1207           else
1208             mask[0] |= (1<<2); /* SHA1 is there for everyone else */
1209         }
1210         else if( preftype == PREFTYPE_ZIP )
1211           mask[0] |= (1<<0); /* Uncompressed is implicit */
1212
1213         if (pkr->pk->user_id) /* selected by user ID */
1214             prefs = pkr->pk->user_id->prefs;
1215         else
1216             prefs = pkr->pk->prefs;
1217
1218         any = 0;
1219         if( prefs ) {
1220             for (i=0; prefs[i].type; i++ ) {
1221                 if( prefs[i].type == preftype ) {
1222                     mask[prefs[i].value/32] |= 1 << (prefs[i].value%32);
1223                     any = 1;
1224                 }
1225             }
1226         }
1227
1228         if( (!prefs || !any) && preftype == PREFTYPE_ZIP ) {
1229             mask[0] |= 3; /* asume no_compression and old pgp */
1230             compr_hack = 1;
1231         }
1232
1233       #if 0
1234         log_debug("pref mask=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
1235                (ulong)mask[7], (ulong)mask[6], (ulong)mask[5], (ulong)mask[4],
1236              (ulong)mask[3], (ulong)mask[2], (ulong)mask[1], (ulong)mask[0]);
1237       #endif
1238         for(i=0; i < 8; i++ )
1239             bits[i] &= mask[i];
1240       #if 0
1241         log_debug("pref bits=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
1242                (ulong)bits[7], (ulong)bits[6], (ulong)bits[5], (ulong)bits[4],
1243              (ulong)bits[3], (ulong)bits[2], (ulong)bits[1], (ulong)bits[0]);
1244       #endif
1245     }
1246     /* usable algorithms are now in bits
1247      * We now use the last key from pk_list to select
1248      * the algorithm we want to use. there are no
1249      * preferences for the last key, we select the one
1250      * corresponding to first set bit.
1251      */
1252     i = -1;
1253     any = 0;
1254
1255     /* Can we use the requested algorithm? */
1256     if(request>-1 && (bits[request/32] & (1<<(request%32))) &&
1257        algo_available(preftype,request,hint))
1258       return request;
1259
1260     /* If we have personal prefs set, use them instead of the last key */
1261     if(preftype==PREFTYPE_SYM && opt.personal_cipher_prefs)
1262       prefs=opt.personal_cipher_prefs;
1263     else if(preftype==PREFTYPE_HASH && opt.personal_digest_prefs)
1264       prefs=opt.personal_digest_prefs;
1265     else if(preftype==PREFTYPE_ZIP && opt.personal_compress_prefs)
1266       prefs=opt.personal_compress_prefs;
1267
1268     if( prefs ) {
1269         for(j=0; prefs[j].type; j++ ) {
1270             if( prefs[j].type == preftype ) {
1271                 if( (bits[prefs[j].value/32] & (1<<(prefs[j].value%32))) ) {
1272                     if( algo_available( preftype, prefs[j].value, hint ) ) {
1273                         any = 1;
1274                         i = prefs[j].value;
1275                         break;
1276                     }
1277                 }
1278             }
1279         }
1280     }
1281     if( !prefs || !any ) {
1282         for(j=0; j < 256; j++ )
1283             if( (bits[j/32] & (1<<(j%32))) ) {
1284                 if( algo_available( preftype, j, hint ) ) {
1285                     i = j;
1286                     break;
1287                 }
1288             }
1289     }
1290
1291   #if 0
1292     log_debug("prefs of type %d: selected %d\n", preftype, i );
1293   #endif
1294     if( compr_hack && !i ) {
1295         /* selected no compression, but we should check whether
1296          * algorithm 1 is also available (the ordering is not relevant
1297          * in this case). */
1298         if( bits[0] & (1<<1) )
1299             i = 1; /* yep; we can use compression algo 1 */
1300     }
1301
1302     /* "If you are building an authentication system, the recipient
1303        may specify a preferred signing algorithm. However, the signer
1304        would be foolish to use a weak algorithm simply because the
1305        recipient requests it." RFC2440:13.  If we settle on MD5, and
1306        SHA1 is also available, use SHA1 instead.  Of course, if the
1307        user intentionally chose MD5 (by putting it in their personal
1308        prefs), then we should do what they say. */
1309
1310     if(preftype==PREFTYPE_HASH &&
1311        i==DIGEST_ALGO_MD5 && (bits[0] & (1<<DIGEST_ALGO_SHA1)))
1312       {
1313         i=DIGEST_ALGO_SHA1;
1314
1315         if(opt.personal_digest_prefs)
1316           for(j=0; prefs[j].type; j++ )
1317             if(opt.personal_digest_prefs[j].type==PREFTYPE_HASH &&
1318                opt.personal_digest_prefs[j].value==DIGEST_ALGO_MD5)
1319               {
1320                 i=DIGEST_ALGO_MD5;
1321                 break;
1322               }
1323       }
1324
1325     return i;
1326 }
1327
1328 /*
1329  * Select the MDC flag from the pk_list.  We can only use MDC if all recipients
1330  * support this feature 
1331  */
1332 int
1333 select_mdc_from_pklist (PK_LIST pk_list)
1334 {
1335     PK_LIST pkr;
1336
1337     if( !pk_list )
1338         return 0;
1339
1340     for (pkr = pk_list; pkr; pkr = pkr->next) {
1341         int mdc;
1342
1343         if (pkr->pk->user_id) /* selected by user ID */
1344             mdc = pkr->pk->user_id->mdc_feature;
1345         else
1346             mdc = pkr->pk->mdc_feature;
1347         if (!mdc)
1348             return 0; /* at least one recipient does not support it */
1349     }
1350     return 1; /* can be used */
1351 }