* keydb.h, getkey.c (key_byname): Flag to enable or disable including
[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             /* We can encrypt-to a disabled key */
830             if( (rc = get_pubkey_byname( pk, rov->d, NULL, NULL, 1 )) ) {
831                 free_public_key( pk ); pk = NULL;
832                 log_error(_("%s: skipped: %s\n"), rov->d, g10_errstr(rc) );
833                 write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
834                                               rov->d, strlen (rov->d), -1);
835                 goto fail;
836             }
837             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use )) ) {
838                 /* Skip the actual key if the key is already present
839                  * in the list */
840                 if (key_present_in_pk_list(pk_list, pk) == 0) {
841                     free_public_key(pk); pk = NULL;
842                     log_info(_("%s: skipped: public key already present\n"),
843                                                             rov->d);
844                 }
845                 else {
846                     PK_LIST r;
847                     r = m_alloc( sizeof *r );
848                     r->pk = pk; pk = NULL;
849                     r->next = pk_list;
850                     r->flags = (rov->flags&2)?1:0;
851                     pk_list = r;
852
853                     if(r->flags&1 && (opt.pgp2 || opt.pgp6 || opt.pgp7))
854                       {
855                         log_info(_("you may not use %s while in %s mode\n"),
856                                  "--hidden-encrypt-to",
857                                  opt.pgp2?"--pgp2":opt.pgp6?"--pgp6":"--pgp7");
858
859                         log_info(_("this message may not be usable by %s\n"),
860                               opt.pgp2?"PGP 2.x":opt.pgp6?"PGP 6.x":"PGP 7.x");
861
862                         opt.pgp2=opt.pgp6=opt.pgp7=0;
863                       }
864                 }
865             }
866             else {
867                 free_public_key( pk ); pk = NULL;
868                 log_error(_("%s: skipped: %s\n"), rov->d, g10_errstr(rc) );
869                 write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
870                                               rov->d, strlen (rov->d), -1);
871                 goto fail;
872             }
873         }
874     }
875
876     if( !any_recipients && !opt.batch ) { /* ask */
877         int have_def_rec;
878         char *answer=NULL;
879         STRLIST backlog=NULL;
880
881         def_rec = default_recipient();
882         have_def_rec = !!def_rec;
883         if( !have_def_rec )
884             tty_printf(_(
885                 "You did not specify a user ID. (you may use \"-r\")\n"));
886         for(;;) {
887             rc = 0;
888             m_free(answer);
889             if( have_def_rec ) {
890                 answer = def_rec;
891                 def_rec = NULL;
892             }
893             else if(backlog) {
894               answer=pop_strlist(&backlog);
895             }
896             else {
897                 answer = cpr_get_utf8("pklist.user_id.enter",
898                          _("\nEnter the user ID.  End with an empty line: "));
899                 trim_spaces(answer);
900                 cpr_kill_prompt();
901             }
902             if( !answer || !*answer ) {
903                 m_free(answer);
904                 break;
905             }
906             if(expand_id(answer,&backlog,0))
907               continue;
908             if( pk )
909                 free_public_key( pk );
910             pk = m_alloc_clear( sizeof *pk );
911             pk->req_usage = use;
912             rc = get_pubkey_byname( pk, answer, NULL, NULL, 0 );
913             if( rc )
914                 tty_printf(_("No such user ID.\n"));
915             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use)) ) {
916                 if( have_def_rec ) {
917                     if (key_present_in_pk_list(pk_list, pk) == 0) {
918                         free_public_key(pk); pk = NULL;
919                         log_info(_("skipped: public key "
920                                    "already set as default recipient\n") );
921                     }
922                     else {
923                         PK_LIST r = m_alloc( sizeof *r );
924                         r->pk = pk; pk = NULL;
925                         r->next = pk_list;
926                         r->flags = 0; /* no throwing default ids */
927                         pk_list = r;
928                     }
929                     any_recipients = 1;
930                     continue;
931                 }
932                 else {
933                     int trustlevel;
934
935                     trustlevel = get_validity (pk, NULL);
936                     if( (trustlevel & TRUST_FLAG_DISABLED) ) {
937                         tty_printf(_("Public key is disabled.\n") );
938                     }
939                     else if( do_we_trust_pre( pk, trustlevel ) ) {
940                         /* Skip the actual key if the key is already present
941                          * in the list */
942                         if (key_present_in_pk_list(pk_list, pk) == 0) {
943                             free_public_key(pk); pk = NULL;
944                             log_info(_("skipped: public key already set\n") );
945                         }
946                         else {
947                             PK_LIST r;
948                             char *p;
949                             size_t n;
950                             u32 keyid[2];
951
952                             keyid_from_pk( pk, keyid);
953                             tty_printf("Added %4u%c/%08lX %s \"",
954                                        nbits_from_pk( pk ),
955                                        pubkey_letter( pk->pubkey_algo ),
956                                        (ulong)keyid[1],
957                                        datestr_from_pk( pk ) );
958                             p = get_user_id( keyid, &n );
959                             tty_print_utf8_string( p, n );
960                             m_free(p);
961                             tty_printf("\"\n");
962
963                             r = m_alloc( sizeof *r );
964                             r->pk = pk; pk = NULL;
965                             r->next = pk_list;
966                             r->flags = 0; /* no throwing interactive ids */
967                             pk_list = r;
968                         }
969                         any_recipients = 1;
970                         continue;
971                     }
972                 }
973             }
974             m_free(def_rec); def_rec = NULL;
975             have_def_rec = 0;
976         }
977         if( pk ) {
978             free_public_key( pk );
979             pk = NULL;
980         }
981     }
982     else if( !any_recipients && (def_rec = default_recipient()) ) {
983         pk = m_alloc_clear( sizeof *pk );
984         pk->req_usage = use;
985         /* The default recipient may be disabled */
986         rc = get_pubkey_byname( pk, def_rec, NULL, NULL, 1 );
987         if( rc )
988             log_error(_("unknown default recipient `%s'\n"), def_rec );
989         else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use)) ) {
990           /* Mark any_recipients here since the default recipient
991              would have been used if it wasn't already there.  It
992              doesn't really matter if we got this key from the default
993              recipient or an encrypt-to. */
994           any_recipients = 1;
995           if (key_present_in_pk_list(pk_list, pk) == 0)
996             log_info(_("skipped: public key already set as default recipient\n"));
997           else {
998             PK_LIST r = m_alloc( sizeof *r );
999             r->pk = pk; pk = NULL;
1000             r->next = pk_list;
1001             r->flags = 0; /* no throwing default ids */
1002             pk_list = r;
1003           }
1004         }
1005         if( pk ) {
1006             free_public_key( pk );
1007             pk = NULL;
1008         }
1009         m_free(def_rec); def_rec = NULL;
1010     }
1011     else {
1012         any_recipients = 0;
1013         for(; remusr; remusr = remusr->next ) {
1014             if( (remusr->flags & 1) )
1015                 continue; /* encrypt-to keys are already handled */
1016
1017             pk = m_alloc_clear( sizeof *pk );
1018             pk->req_usage = use;
1019             if( (rc = get_pubkey_byname( pk, remusr->d, NULL, NULL, 0 )) ) {
1020                 free_public_key( pk ); pk = NULL;
1021                 log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
1022                 write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
1023                                               remusr->d, strlen (remusr->d),
1024                                               -1);
1025                 goto fail;
1026             }
1027             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use )) ) {
1028                 int trustlevel;
1029
1030                 trustlevel = get_validity (pk, pk->namehash);
1031                 if( (trustlevel & TRUST_FLAG_DISABLED) ) {
1032                     free_public_key(pk); pk = NULL;
1033                     log_info(_("%s: skipped: public key is disabled\n"),
1034                                                                     remusr->d);
1035                     write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
1036                                                   remusr->d,
1037                                                   strlen (remusr->d),
1038                                                   -1);
1039                     rc=G10ERR_UNU_PUBKEY;
1040                     goto fail;
1041                 }
1042                 else if( do_we_trust_pre( pk, trustlevel ) ) {
1043                     /* note: do_we_trust may have changed the trustlevel */
1044
1045                     /* We have at least one valid recipient. It doesn't matters
1046                      * if this recipient is already present. */
1047                     any_recipients = 1;
1048
1049                     /* Skip the actual key if the key is already present
1050                      * in the list */
1051                     if (key_present_in_pk_list(pk_list, pk) == 0) {
1052                         free_public_key(pk); pk = NULL;
1053                         log_info(_("%s: skipped: public key already present\n"),
1054                                                                     remusr->d);
1055                     }
1056                     else {
1057                         PK_LIST r;
1058                         r = m_alloc( sizeof *r );
1059                         r->pk = pk; pk = NULL;
1060                         r->next = pk_list;
1061                         r->flags = (remusr->flags&2)?1:0;
1062                         pk_list = r;
1063                     }
1064                 }
1065                 else { /* we don't trust this pk */
1066                     free_public_key( pk ); pk = NULL;
1067                     write_status_text_and_buffer (STATUS_INV_RECP, "10 ",
1068                                                   remusr->d,
1069                                                   strlen (remusr->d),
1070                                                   -1);
1071                     rc=G10ERR_UNU_PUBKEY;
1072                     goto fail;
1073                 }
1074             }
1075             else {
1076                 free_public_key( pk ); pk = NULL;
1077                 write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
1078                                               remusr->d,
1079                                               strlen (remusr->d),
1080                                               -1);
1081                 log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
1082                 goto fail;
1083             }
1084         }
1085     }
1086
1087     if( !rc && !any_recipients ) {
1088         log_error(_("no valid addressees\n"));
1089         write_status_text (STATUS_NO_RECP, "0");
1090         rc = G10ERR_NO_USER_ID;
1091     }
1092
1093  fail:
1094
1095     if( rc )
1096         release_pk_list( pk_list );
1097     else
1098         *ret_pk_list = pk_list;
1099     if(opt.grouplist)
1100       free_strlist(remusr);
1101     return rc;
1102 }
1103
1104
1105 /* In pgp6 mode, disallow all ciphers except IDEA (1), 3DES (2), and
1106    CAST5 (3), all hashes except MD5 (1), SHA1 (2), and RIPEMD160 (3),
1107    and all compressions except none (0) and ZIP (1).  pgp7 and pgp8
1108    mode expands the cipher list to include AES128 (7), AES192 (8),
1109    AES256 (9), and TWOFISH (10).  For a true PGP key all of this is
1110    unneeded as they are the only items present in the preferences
1111    subpacket, but checking here covers the weird case of encrypting to
1112    a key that had preferences from a different implementation which
1113    was then used with PGP.  I am not completely comfortable with this
1114    as the right thing to do, as it slightly alters the list of what
1115    the user is supposedly requesting.  It is not against the RFC
1116    however, as the preference chosen will never be one that the user
1117    didn't specify somewhere ("The implementation may use any mechanism
1118    to pick an algorithm in the intersection"), and PGP has no
1119    mechanism to fix such a broken preference list, so I'm including
1120    it. -dms */
1121
1122 static int
1123 algo_available( int preftype, int algo, void *hint )
1124 {
1125     if( preftype == PREFTYPE_SYM ) {
1126         if( opt.pgp6 && ( algo != 1 && algo != 2 && algo != 3) )
1127           return 0;
1128
1129         if( (opt.pgp7 || opt.pgp8)
1130             && (algo != 1 && algo != 2 && algo != 3
1131                 && algo != 7 && algo != 8 && algo != 9 && algo != 10) )
1132           return 0;
1133
1134         return algo && !check_cipher_algo( algo );
1135     }
1136     else if( preftype == PREFTYPE_HASH ) {
1137         int bits=0;
1138
1139         if(hint)
1140           bits=*(int *)hint;
1141
1142         if(bits && (bits != md_digest_length(algo)))
1143           return 0;
1144
1145         if( (opt.pgp6 || opt.pgp7 || opt.pgp8 )
1146             && ( algo != 1 && algo != 2 && algo != 3) )
1147           return 0;
1148
1149         return algo && !check_digest_algo( algo );
1150     }
1151     else if( preftype == PREFTYPE_ZIP ) {
1152         if ( ( opt.pgp6 || opt.pgp7 || opt.pgp8 )
1153              && ( algo !=0 && algo != 1) )
1154           return 0;
1155
1156         return !check_compress_algo( algo );
1157     }
1158     else
1159         return 0;
1160 }
1161
1162
1163
1164 /****************
1165  * Return -1 if we could not find an algorithm.
1166  */
1167 int
1168 select_algo_from_prefs(PK_LIST pk_list, int preftype, int request, void *hint)
1169 {
1170     PK_LIST pkr;
1171     u32 bits[8];
1172     const prefitem_t *prefs;
1173     int i, j;
1174     int compr_hack=0;
1175     int any;
1176
1177     if( !pk_list )
1178         return -1;
1179
1180     memset( bits, ~0, 8 * sizeof *bits );
1181     for( pkr = pk_list; pkr; pkr = pkr->next ) {
1182         u32 mask[8];
1183
1184         memset( mask, 0, 8 * sizeof *mask );
1185         if( preftype == PREFTYPE_SYM ) {
1186           if( opt.pgp2 &&
1187               pkr->pk->version < 4 &&
1188               pkr->pk->selfsigversion < 4 )
1189             mask[0] |= (1<<1); /* IDEA is implicitly there for v3 keys
1190                                   with v3 selfsigs (rfc2440:12.1) if
1191                                   --pgp2 mode is on.  This doesn't
1192                                   mean it's actually available, of
1193                                   course. */
1194           else
1195             mask[0] |= (1<<2); /* 3DES is implicitly there for everyone else */
1196         }
1197         else if( preftype == PREFTYPE_HASH ) {
1198           /* While I am including this code for completeness, note
1199              that currently --pgp2 mode locks the hash at MD5, so this
1200              function will never even be called.  Even if the hash
1201              wasn't locked at MD5, we don't support sign+encrypt in
1202              --pgp2 mode, and that's the only time PREFTYPE_HASH is
1203              used anyway. -dms */
1204           if( opt.pgp2 &&
1205               pkr->pk->version < 4 &&
1206               pkr->pk->selfsigversion < 4 )
1207             mask[0] |= (1<<1); /* MD5 is there for v3 keys with v3
1208                                   selfsigs when --pgp2 is on. */
1209           else
1210             mask[0] |= (1<<2); /* SHA1 is there for everyone else */
1211         }
1212         else if( preftype == PREFTYPE_ZIP )
1213           mask[0] |= (1<<0); /* Uncompressed is implicit */
1214
1215         if (pkr->pk->user_id) /* selected by user ID */
1216             prefs = pkr->pk->user_id->prefs;
1217         else
1218             prefs = pkr->pk->prefs;
1219
1220         any = 0;
1221         if( prefs ) {
1222             for (i=0; prefs[i].type; i++ ) {
1223                 if( prefs[i].type == preftype ) {
1224                     mask[prefs[i].value/32] |= 1 << (prefs[i].value%32);
1225                     any = 1;
1226                 }
1227             }
1228         }
1229
1230         if( (!prefs || !any) && preftype == PREFTYPE_ZIP ) {
1231             mask[0] |= 3; /* asume no_compression and old pgp */
1232             compr_hack = 1;
1233         }
1234
1235       #if 0
1236         log_debug("pref mask=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
1237                (ulong)mask[7], (ulong)mask[6], (ulong)mask[5], (ulong)mask[4],
1238              (ulong)mask[3], (ulong)mask[2], (ulong)mask[1], (ulong)mask[0]);
1239       #endif
1240         for(i=0; i < 8; i++ )
1241             bits[i] &= mask[i];
1242       #if 0
1243         log_debug("pref bits=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
1244                (ulong)bits[7], (ulong)bits[6], (ulong)bits[5], (ulong)bits[4],
1245              (ulong)bits[3], (ulong)bits[2], (ulong)bits[1], (ulong)bits[0]);
1246       #endif
1247     }
1248     /* usable algorithms are now in bits
1249      * We now use the last key from pk_list to select
1250      * the algorithm we want to use. there are no
1251      * preferences for the last key, we select the one
1252      * corresponding to first set bit.
1253      */
1254     i = -1;
1255     any = 0;
1256
1257     /* Can we use the requested algorithm? */
1258     if(request>-1 && (bits[request/32] & (1<<(request%32))) &&
1259        algo_available(preftype,request,hint))
1260       return request;
1261
1262     /* If we have personal prefs set, use them instead of the last key */
1263     if(preftype==PREFTYPE_SYM && opt.personal_cipher_prefs)
1264       prefs=opt.personal_cipher_prefs;
1265     else if(preftype==PREFTYPE_HASH && opt.personal_digest_prefs)
1266       prefs=opt.personal_digest_prefs;
1267     else if(preftype==PREFTYPE_ZIP && opt.personal_compress_prefs)
1268       prefs=opt.personal_compress_prefs;
1269
1270     if( prefs ) {
1271         for(j=0; prefs[j].type; j++ ) {
1272             if( prefs[j].type == preftype ) {
1273                 if( (bits[prefs[j].value/32] & (1<<(prefs[j].value%32))) ) {
1274                     if( algo_available( preftype, prefs[j].value, hint ) ) {
1275                         any = 1;
1276                         i = prefs[j].value;
1277                         break;
1278                     }
1279                 }
1280             }
1281         }
1282     }
1283     if( !prefs || !any ) {
1284         for(j=0; j < 256; j++ )
1285             if( (bits[j/32] & (1<<(j%32))) ) {
1286                 if( algo_available( preftype, j, hint ) ) {
1287                     i = j;
1288                     break;
1289                 }
1290             }
1291     }
1292
1293   #if 0
1294     log_debug("prefs of type %d: selected %d\n", preftype, i );
1295   #endif
1296     if( compr_hack && !i ) {
1297         /* selected no compression, but we should check whether
1298          * algorithm 1 is also available (the ordering is not relevant
1299          * in this case). */
1300         if( bits[0] & (1<<1) )
1301             i = 1; /* yep; we can use compression algo 1 */
1302     }
1303
1304     /* "If you are building an authentication system, the recipient
1305        may specify a preferred signing algorithm. However, the signer
1306        would be foolish to use a weak algorithm simply because the
1307        recipient requests it." RFC2440:13.  If we settle on MD5, and
1308        SHA1 is also available, use SHA1 instead.  Of course, if the
1309        user intentionally chose MD5 (by putting it in their personal
1310        prefs), then we should do what they say. */
1311
1312     if(preftype==PREFTYPE_HASH &&
1313        i==DIGEST_ALGO_MD5 && (bits[0] & (1<<DIGEST_ALGO_SHA1)))
1314       {
1315         i=DIGEST_ALGO_SHA1;
1316
1317         if(opt.personal_digest_prefs)
1318           for(j=0; prefs[j].type; j++ )
1319             if(opt.personal_digest_prefs[j].type==PREFTYPE_HASH &&
1320                opt.personal_digest_prefs[j].value==DIGEST_ALGO_MD5)
1321               {
1322                 i=DIGEST_ALGO_MD5;
1323                 break;
1324               }
1325       }
1326
1327     return i;
1328 }
1329
1330 /*
1331  * Select the MDC flag from the pk_list.  We can only use MDC if all recipients
1332  * support this feature 
1333  */
1334 int
1335 select_mdc_from_pklist (PK_LIST pk_list)
1336 {
1337     PK_LIST pkr;
1338
1339     if( !pk_list )
1340         return 0;
1341
1342     for (pkr = pk_list; pkr; pkr = pkr->next) {
1343         int mdc;
1344
1345         if (pkr->pk->user_id) /* selected by user ID */
1346             mdc = pkr->pk->user_id->mdc_feature;
1347         else
1348             mdc = pkr->pk->mdc_feature;
1349         if (!mdc)
1350             return 0; /* at least one recipient does not support it */
1351     }
1352     return 1; /* can be used */
1353 }