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