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