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