* pkclist.c (do_edit_ownertrust): Show all user IDs. This should
[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 did_help=defer_help;
249
250   keyid_from_pk (pk, keyid);
251   for(;;) {
252     /* a string with valid answers */
253     const char *ans = _("iImMqQsS");
254
255     if( !did_help ) 
256       {
257         if( !mode ) 
258           {
259             KBNODE keyblock, un;
260
261             tty_printf(_("No trust value assigned to:\n"
262                          "%4u%c/%08lX %s \""),
263                        nbits_from_pk( pk ), pubkey_letter( pk->pubkey_algo ),
264                        (ulong)keyid[1], datestr_from_pk( pk ) );
265             p = get_user_id( keyid, &n );
266             tty_print_utf8_string( p, n ),
267               m_free(p);
268             tty_printf("\"\n");
269
270             keyblock = get_pubkeyblock (keyid);
271             if (!keyblock)
272                 BUG ();
273             for (un=keyblock; un; un = un->next) {
274                 if (un->pkt->pkttype != PKT_USER_ID )
275                     continue;
276                 if (un->pkt->pkt.user_id->is_revoked )
277                     continue;
278                 if (un->pkt->pkt.user_id->is_expired )
279                     continue;
280                 /* Only skip textual primaries */
281                 if (un->pkt->pkt.user_id->is_primary &&
282                     !un->pkt->pkt.user_id->attrib_data )
283                     continue;
284                 
285                 if(opt.show_photos && un->pkt->pkt.user_id->attrib_data)
286                     show_photos(un->pkt->pkt.user_id->attribs,
287                                 un->pkt->pkt.user_id->numattribs,pk,NULL);
288                 
289                 tty_printf ("      %s", _("                aka \""));
290                 tty_print_utf8_string (un->pkt->pkt.user_id->name,
291                                        un->pkt->pkt.user_id->len );
292                 tty_printf("\"\n");
293             }
294         
295             print_fingerprint (pk, NULL, 2);
296             tty_printf("\n");
297           }
298         tty_printf (_(
299                      "Please decide how far you trust this user to correctly\n"
300                      "verify other users' keys (by looking at passports,\n"
301                      "checking fingerprints from different sources...)?\n\n"));
302         tty_printf (_(" %d = Don't know\n"), 1);
303         tty_printf (_(" %d = I do NOT trust\n"), 2);
304         tty_printf (_(" %d = I trust marginally\n"), 3);
305         tty_printf (_(" %d = I trust fully\n"), 4);
306         if (mode)
307           tty_printf (_(" %d = I trust ultimately\n"), 5);
308 #if 0
309         /* not yet implemented */
310         tty_printf (_(" i = please show me more information\n") );
311 #endif
312         if( mode )
313           tty_printf(_(" m = back to the main menu\n"));
314         else
315           {
316             tty_printf(_(" s = skip this key\n"));
317             tty_printf(_(" q = quit\n"));
318           }
319         tty_printf("\n");
320         did_help = 1;
321       }
322     if( strlen(ans) != 8 )
323       BUG();
324     p = cpr_get("edit_ownertrust.value",_("Your decision? "));
325     trim_spaces(p);
326     cpr_kill_prompt();
327     if( !*p )
328       did_help = 0;
329     else if( *p && p[1] )
330       ;
331     else if( !p[1] && (*p >= '1' && *p <= (mode?'5':'4')) ) 
332       {
333         unsigned int trust;
334         switch( *p )
335           {
336           case '1': trust = TRUST_UNDEFINED; break;
337           case '2': trust = TRUST_NEVER    ; break;
338           case '3': trust = TRUST_MARGINAL ; break;
339           case '4': trust = TRUST_FULLY    ; break;
340           case '5': trust = TRUST_ULTIMATE ; break;
341           default: BUG();
342           }
343         if (trust == TRUST_ULTIMATE
344             && !cpr_get_answer_is_yes ("edit_ownertrust.set_ultimate.okay",
345                                        _("Do you really want to set this key"
346                                          " to ultimate trust? ")))
347           ; /* no */
348         else
349           {
350             *new_trust = trust;
351             changed = 1;
352             break;
353           }
354       }
355 #if 0
356     /* not yet implemented */
357     else if( *p == ans[0] || *p == ans[1] ) 
358       {
359         tty_printf(_("Certificates leading to an ultimately trusted key:\n"));
360         show = 1;
361         break;
362       }
363 #endif
364     else if( mode && (*p == ans[2] || *p == ans[3] || *p == CONTROL_D ) ) 
365       {
366         break ; /* back to the menu */
367       }
368     else if( !mode && (*p == ans[6] || *p == ans[7] ) )
369       {
370         break; /* skip */
371       }
372     else if( !mode && (*p == ans[4] || *p == ans[5] ) )
373       {
374         quit = 1;
375         break ; /* back to the menu */
376       }
377     m_free(p); p = NULL;
378   }
379   m_free(p);
380   return show? -2: quit? -1 : changed;
381 }
382
383 /* 
384  * Display a menu to change the ownertrust of the key PK (which should
385  * be a primary key).  
386  * For mode values see do_edit_ownertrust ()
387  */
388 int
389 edit_ownertrust (PKT_public_key *pk, int mode )
390 {
391   unsigned int trust;
392   int no_help = 0;
393
394   for(;;)
395     {
396       switch ( do_edit_ownertrust (pk, mode, &trust, no_help ) )
397         {
398         case -1: /* quit */
399           return -1;
400         case -2: /* show info */
401           show_paths(pk, 1);
402           no_help = 1;
403           break;
404         case 1: /* trust value set */
405           trust &= ~TRUST_FLAG_DISABLED;
406           trust |= get_ownertrust (pk) & TRUST_FLAG_DISABLED;
407           update_ownertrust (pk, trust );
408           return 1;
409         default:
410           return 0;
411         }
412     }
413 }
414
415
416 /****************
417  * Check whether we can trust this pk which has a trustlevel of TRUSTLEVEL
418  * Returns: true if we trust.
419  */
420 static int
421 do_we_trust( PKT_public_key *pk, unsigned int *trustlevel )
422 {
423     unsigned int trustmask = 0;
424
425     /* FIXME: get_pubkey_byname already checks the validity and won't
426      * return keys which are either expired or revoked - so these
427      * question here won't get triggered.  We have to find a solution
428      * for this.  It might make sense to have a function in getkey.c
429      * which does only the basic checks and returns even revoked and
430      * expired keys.  This fnction could then also returhn a list of
431      * keys if the speicified name is ambiguous
432      */
433     if( (*trustlevel & TRUST_FLAG_REVOKED) ) {
434         log_info(_("key %08lX: key has been revoked!\n"),
435                                         (ulong)keyid_from_pk( pk, NULL) );
436         show_revocation_reason( pk, 0 );
437         if( opt.batch )
438           return 0; /* no */
439
440         if( !cpr_get_answer_is_yes("revoked_key.override",
441                                     _("Use this key anyway? ")) )
442           return 0; /* no */
443         trustmask |= TRUST_FLAG_REVOKED;
444     }
445     if( (*trustlevel & TRUST_FLAG_SUB_REVOKED) ) {
446         log_info(_("key %08lX: subkey has been revoked!\n"),
447                                         (ulong)keyid_from_pk( pk, NULL) );
448         show_revocation_reason( pk, 0 );
449         if( opt.batch )
450             return 0;
451
452         if( !cpr_get_answer_is_yes("revoked_key.override",
453                                     _("Use this key anyway? ")) )
454             return 0;
455         trustmask |= TRUST_FLAG_SUB_REVOKED;
456     }
457     *trustlevel &= ~trustmask;
458
459     if( opt.always_trust) {
460         if( opt.verbose )
461             log_info("No trust check due to --always-trust option\n");
462         return 1;
463     }
464
465     switch( (*trustlevel & TRUST_MASK) ) {
466       case TRUST_EXPIRED:
467         log_info(_("%08lX: key has expired\n"),
468                                     (ulong)keyid_from_pk( pk, NULL) );
469         return 0; /* no */
470
471       default:
472          log_error ("invalid trustlevel %u returned from validation layer\n",
473                     *trustlevel);
474          /* fall thru */
475       case TRUST_UNKNOWN: 
476       case TRUST_UNDEFINED:
477         log_info(_("%08lX: There is no indication that this key "
478                    "really belongs to the owner\n"),
479                  (ulong)keyid_from_pk( pk, NULL) );
480         return 0; /* no */
481
482       case TRUST_NEVER:
483         log_info(_("%08lX: We do NOT trust this key\n"),
484                                         (ulong)keyid_from_pk( pk, NULL) );
485         return 0; /* no */
486
487       case TRUST_MARGINAL:
488         log_info(
489        _("%08lX: It is not sure that this key really belongs to the owner\n"
490          "but it is accepted anyway\n"), (ulong)keyid_from_pk( pk, NULL) );
491         return 1; /* yes */
492
493       case TRUST_FULLY:
494         if( opt.verbose )
495             log_info(_("This key probably belongs to the owner\n"));
496         return 1; /* yes */
497
498       case TRUST_ULTIMATE:
499         if( opt.verbose )
500             log_info(_("This key belongs to us\n"));
501         return 1; /* yes */
502     }
503
504     return 1; /* yes */
505 }
506
507
508
509 /****************
510  * wrapper around do_we_trust, so we can ask whether to use the
511  * key anyway.
512  */
513 static int
514 do_we_trust_pre( PKT_public_key *pk, unsigned int trustlevel )
515 {
516     int rc;
517
518     rc = do_we_trust( pk, &trustlevel );
519
520     if( (trustlevel & TRUST_FLAG_REVOKED) && !rc )
521         return 0;
522     if( (trustlevel & TRUST_FLAG_SUB_REVOKED) && !rc )
523         return 0;
524
525     if( !opt.batch && !rc ) {
526         char *p;
527         u32 keyid[2];
528         size_t n;
529
530         keyid_from_pk( pk, keyid);
531         tty_printf( "%4u%c/%08lX %s \"",
532                   nbits_from_pk( pk ), pubkey_letter( pk->pubkey_algo ),
533                   (ulong)keyid[1], datestr_from_pk( pk ) );
534         p = get_user_id( keyid, &n );
535         tty_print_utf8_string( p, n ),
536         m_free(p);
537         tty_printf("\"\n");
538         print_fingerprint (pk, NULL, 2);
539         tty_printf("\n");
540
541         tty_printf(_(
542 "It is NOT certain that the key belongs to the person named\n"
543 "in the user ID.  If you *really* know what you are doing,\n"
544 "you may answer the next question with yes\n\n"));
545
546         if( cpr_get_answer_is_yes("untrusted_key.override",
547                                   _("Use this key anyway? "))  )
548             rc = 1;
549
550         /* Hmmm: Should we set a flag to tell the user about
551          *       his decision the next time he encrypts for this recipient?
552          */
553     }
554     else if( opt.always_trust && !rc ) {
555         if( !opt.quiet )
556             log_info(_("WARNING: Using untrusted key!\n"));
557         rc = 1;
558     }
559     return rc;
560 }
561
562
563
564 /****************
565  * Check whether we can trust this signature.
566  * Returns: Error if we shall not trust this signatures.
567  */
568 int
569 check_signatures_trust( PKT_signature *sig )
570 {
571   PKT_public_key *pk = m_alloc_clear( sizeof *pk );
572   unsigned int trustlevel;
573   int rc=0;
574
575   if ( opt.always_trust)
576     {
577       if( !opt.quiet )
578         log_info(_("WARNING: Using untrusted key!\n"));
579       if (opt.with_fingerprint)
580         print_fingerprint (pk, NULL, 1);
581       goto leave;
582     }
583
584   rc = get_pubkey( pk, sig->keyid );
585   if (rc) 
586     { /* this should not happen */
587       log_error("Ooops; the key vanished  - can't check the trust\n");
588       rc = G10ERR_NO_PUBKEY;
589       goto leave;
590     }
591
592   trustlevel = get_validity (pk, NULL);
593
594   if ( (trustlevel & TRUST_FLAG_REVOKED) ) 
595     {
596       write_status( STATUS_KEYREVOKED );
597       log_info(_("WARNING: This key has been revoked by its owner!\n"));
598       log_info(_("         This could mean that the signature is forgery.\n"));
599       show_revocation_reason( pk, 0 );
600     }
601   else if ((trustlevel & TRUST_FLAG_SUB_REVOKED) ) 
602     {
603       write_status( STATUS_KEYREVOKED );
604       log_info(_("WARNING: This subkey has been revoked by its owner!\n"));
605       show_revocation_reason( pk, 0 );
606     }
607   
608   if ((trustlevel & TRUST_FLAG_DISABLED))
609     log_info (_("Note: This key has been disabled.\n"));
610
611   switch ( (trustlevel & TRUST_MASK) ) 
612     {
613     case TRUST_EXPIRED:
614       log_info(_("Note: This key has expired!\n"));
615       print_fingerprint (pk, NULL, 1);
616       break;
617         
618     default:
619       log_error ("invalid trustlevel %u returned from validation layer\n",
620                  trustlevel);
621       /* fall thru */
622     case TRUST_UNKNOWN: 
623     case TRUST_UNDEFINED:
624       write_status( STATUS_TRUST_UNDEFINED );
625       log_info(_("WARNING: This key is not certified with"
626                  " a trusted signature!\n"));
627       log_info(_("         There is no indication that the "
628                  "signature belongs to the owner.\n" ));
629       print_fingerprint (pk, NULL, 1);
630       break;
631
632     case TRUST_NEVER:
633       /* currently we won't get that status */
634       write_status( STATUS_TRUST_NEVER );
635       log_info(_("WARNING: We do NOT trust this key!\n"));
636       log_info(_("         The signature is probably a FORGERY.\n"));
637       if (opt.with_fingerprint)
638         print_fingerprint (pk, NULL, 1);
639       rc = G10ERR_BAD_SIGN;
640       break;
641
642     case TRUST_MARGINAL:
643       write_status( STATUS_TRUST_MARGINAL );
644       log_info(_("WARNING: This key is not certified with"
645                  " sufficiently trusted signatures!\n"));
646       log_info(_("         It is not certain that the"
647                  " signature belongs to the owner.\n" ));
648       print_fingerprint (pk, NULL, 1);
649       break;
650
651     case TRUST_FULLY:
652       write_status( STATUS_TRUST_FULLY );
653       if (opt.with_fingerprint)
654         print_fingerprint (pk, NULL, 1);
655       break;
656
657     case TRUST_ULTIMATE:
658       write_status( STATUS_TRUST_ULTIMATE );
659       if (opt.with_fingerprint)
660         print_fingerprint (pk, NULL, 1);
661       break;
662     }
663
664  leave:
665   free_public_key( pk );
666   return rc;
667 }
668
669
670 void
671 release_pk_list( PK_LIST pk_list )
672 {
673     PK_LIST pk_rover;
674
675     for( ; pk_list; pk_list = pk_rover ) {
676         pk_rover = pk_list->next;
677         free_public_key( pk_list->pk );
678         m_free( pk_list );
679     }
680 }
681
682
683 static int
684 key_present_in_pk_list(PK_LIST pk_list, PKT_public_key *pk)
685 {
686     for( ; pk_list; pk_list = pk_list->next)
687         if (cmp_public_keys(pk_list->pk, pk) == 0)
688             return 0;
689
690     return -1;
691 }
692
693
694 /****************
695  * Return a malloced string with a default reciepient if there is any
696  */
697 static char *
698 default_recipient(void)
699 {
700     PKT_secret_key *sk;
701     byte fpr[MAX_FINGERPRINT_LEN+1];
702     size_t n;
703     char *p;
704     int i;
705
706     if( opt.def_recipient )
707         return m_strdup( opt.def_recipient );
708     if( !opt.def_recipient_self )
709         return NULL;
710     sk = m_alloc_clear( sizeof *sk );
711     i = get_seckey_byname( sk, NULL, 0 );
712     if( i ) {
713         free_secret_key( sk );
714         return NULL;
715     }
716     n = MAX_FINGERPRINT_LEN;
717     fingerprint_from_sk( sk, fpr, &n );
718     free_secret_key( sk );
719     p = m_alloc( 2*n+3 );
720     *p++ = '0';
721     *p++ = 'x';
722     for(i=0; i < n; i++ )
723         sprintf( p+2*i, "%02X", fpr[i] );
724     p -= 2;
725     return p;
726 }
727
728 static int
729 expand_id(const char *id,STRLIST *into,unsigned int flags)
730 {
731   struct groupitem *groups;
732   int count=0;
733
734   for(groups=opt.grouplist;groups;groups=groups->next)
735     {
736       /* need strcasecmp() here, as this should be localized */
737       if(strcasecmp(groups->name,id)==0)
738         {
739           STRLIST each,sl;
740
741           /* this maintains the current utf8-ness */
742           for(each=groups->values;each;each=each->next)
743             {
744               sl=add_to_strlist(into,each->d);
745               sl->flags=flags;
746               count++;
747             }
748
749           break;
750         }
751     }
752
753   return count;
754 }
755
756 /* For simplicity, and to avoid potential loops, we only expand once -
757    you can't make an alias that points to an alias. */
758 static STRLIST
759 expand_group(STRLIST input)
760 {
761   STRLIST sl,output=NULL,rover;
762
763   for(rover=input;rover;rover=rover->next)
764     if(expand_id(rover->d,&output,rover->flags)==0)
765       {
766         /* Didn't find any groups, so use the existing string */
767         sl=add_to_strlist(&output,rover->d);
768         sl->flags=rover->flags;
769       }
770
771   return output;
772 }
773
774 int
775 build_pk_list( STRLIST rcpts, PK_LIST *ret_pk_list, unsigned use )
776 {
777     PK_LIST pk_list = NULL;
778     PKT_public_key *pk=NULL;
779     int rc=0;
780     int any_recipients=0;
781     STRLIST rov,remusr;
782     char *def_rec = NULL;
783
784     if(opt.grouplist)
785       remusr=expand_group(rcpts);
786     else
787       remusr=rcpts;
788
789     /* check whether there are any recipients in the list and build the
790      * list of the encrypt-to ones (we always trust them) */
791     for( rov = remusr; rov; rov = rov->next ) {
792         if( !(rov->flags & 1) )
793             any_recipients = 1;
794         else if( (use & PUBKEY_USAGE_ENC) && !opt.no_encrypt_to ) {
795             pk = m_alloc_clear( sizeof *pk );
796             pk->req_usage = use;
797             if( (rc = get_pubkey_byname( pk, rov->d, NULL, NULL )) ) {
798                 free_public_key( pk ); pk = NULL;
799                 log_error(_("%s: skipped: %s\n"), rov->d, g10_errstr(rc) );
800                 write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
801                                               rov->d, strlen (rov->d), -1);
802                 goto fail;
803             }
804             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use )) ) {
805                 /* Skip the actual key if the key is already present
806                  * in the list */
807                 if (key_present_in_pk_list(pk_list, pk) == 0) {
808                     free_public_key(pk); pk = NULL;
809                     log_info(_("%s: skipped: public key already present\n"),
810                                                             rov->d);
811                 }
812                 else {
813                     PK_LIST r;
814                     r = m_alloc( sizeof *r );
815                     r->pk = pk; pk = NULL;
816                     r->next = pk_list;
817                     r->mark = 0;
818                     pk_list = r;
819                 }
820             }
821             else {
822                 free_public_key( pk ); pk = NULL;
823                 log_error(_("%s: skipped: %s\n"), rov->d, g10_errstr(rc) );
824                 write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
825                                               rov->d, strlen (rov->d), -1);
826                 goto fail;
827             }
828         }
829     }
830
831     if( !any_recipients && !opt.batch ) { /* ask */
832         int have_def_rec;
833         char *answer=NULL;
834         STRLIST backlog=NULL;
835
836         def_rec = default_recipient();
837         have_def_rec = !!def_rec;
838         if( !have_def_rec )
839             tty_printf(_(
840                 "You did not specify a user ID. (you may use \"-r\")\n"));
841         for(;;) {
842             rc = 0;
843             m_free(answer);
844             if( have_def_rec ) {
845                 answer = def_rec;
846                 def_rec = NULL;
847             }
848             else if(backlog) {
849               answer=pop_strlist(&backlog);
850             }
851             else {
852                 answer = cpr_get_utf8("pklist.user_id.enter",
853                          _("\nEnter the user ID.  End with an empty line: "));
854                 trim_spaces(answer);
855                 cpr_kill_prompt();
856             }
857             if( !answer || !*answer ) {
858                 m_free(answer);
859                 break;
860             }
861             if(expand_id(answer,&backlog,0))
862               continue;
863             if( pk )
864                 free_public_key( pk );
865             pk = m_alloc_clear( sizeof *pk );
866             pk->req_usage = use;
867             rc = get_pubkey_byname( pk, answer, NULL, NULL );
868             if( rc )
869                 tty_printf(_("No such user ID.\n"));
870             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use)) ) {
871                 if( have_def_rec ) {
872                     if (key_present_in_pk_list(pk_list, pk) == 0) {
873                         free_public_key(pk); pk = NULL;
874                         log_info(_("skipped: public key "
875                                    "already set as default recipient\n") );
876                     }
877                     else {
878                         PK_LIST r = m_alloc( sizeof *r );
879                         r->pk = pk; pk = NULL;
880                         r->next = pk_list;
881                         r->mark = 0;
882                         pk_list = r;
883                     }
884                     any_recipients = 1;
885                     continue;
886                 }
887                 else {
888                     int trustlevel;
889
890                     trustlevel = get_validity (pk, NULL);
891                     if( (trustlevel & TRUST_FLAG_DISABLED) ) {
892                         tty_printf(_("Public key is disabled.\n") );
893                     }
894                     else if( do_we_trust_pre( pk, trustlevel ) ) {
895                         /* Skip the actual key if the key is already present
896                          * in the list */
897                         if (key_present_in_pk_list(pk_list, pk) == 0) {
898                             free_public_key(pk); pk = NULL;
899                             log_info(_("skipped: public key already set\n") );
900                         }
901                         else {
902                             PK_LIST r;
903                             char *p;
904                             size_t n;
905                             u32 keyid[2];
906
907                             keyid_from_pk( pk, keyid);
908                             tty_printf("Added %4u%c/%08lX %s \"",
909                                        nbits_from_pk( pk ),
910                                        pubkey_letter( pk->pubkey_algo ),
911                                        (ulong)keyid[1],
912                                        datestr_from_pk( pk ) );
913                             p = get_user_id( keyid, &n );
914                             tty_print_utf8_string( p, n );
915                             m_free(p);
916                             tty_printf("\"\n");
917
918                             r = m_alloc( sizeof *r );
919                             r->pk = pk; pk = NULL;
920                             r->next = pk_list;
921                             r->mark = 0;
922                             pk_list = r;
923                         }
924                         any_recipients = 1;
925                         continue;
926                     }
927                 }
928             }
929             m_free(def_rec); def_rec = NULL;
930             have_def_rec = 0;
931         }
932         if( pk ) {
933             free_public_key( pk );
934             pk = NULL;
935         }
936     }
937     else if( !any_recipients && (def_rec = default_recipient()) ) {
938         pk = m_alloc_clear( sizeof *pk );
939         pk->req_usage = use;
940         rc = get_pubkey_byname( pk, def_rec, NULL, NULL );
941         if( rc )
942             log_error(_("unknown default recipient `%s'\n"), def_rec );
943         else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use)) ) {
944           /* Mark any_recipients here since the default recipient
945              would have been used if it wasn't already there.  It
946              doesn't really matter if we got this key from the default
947              recipient or an encrypt-to. */
948           any_recipients = 1;
949           if (key_present_in_pk_list(pk_list, pk) == 0)
950             log_info(_("skipped: public key already set as default recipient\n"));
951           else {
952             PK_LIST r = m_alloc( sizeof *r );
953             r->pk = pk; pk = NULL;
954             r->next = pk_list;
955             r->mark = 0;
956             pk_list = r;
957           }
958         }
959         if( pk ) {
960             free_public_key( pk );
961             pk = NULL;
962         }
963         m_free(def_rec); def_rec = NULL;
964     }
965     else {
966         any_recipients = 0;
967         for(; remusr; remusr = remusr->next ) {
968             if( (remusr->flags & 1) )
969                 continue; /* encrypt-to keys are already handled */
970
971             pk = m_alloc_clear( sizeof *pk );
972             pk->req_usage = use;
973             if( (rc = get_pubkey_byname( pk, remusr->d, NULL, NULL )) ) {
974                 free_public_key( pk ); pk = NULL;
975                 log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
976                 write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
977                                               remusr->d, strlen (remusr->d),
978                                               -1);
979                 goto fail;
980             }
981             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use )) ) {
982                 int trustlevel;
983
984                 trustlevel = get_validity (pk, pk->namehash);
985                 if( (trustlevel & TRUST_FLAG_DISABLED) ) {
986                     free_public_key(pk); pk = NULL;
987                     log_info(_("%s: skipped: public key is disabled\n"),
988                                                                     remusr->d);
989                     write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
990                                                   remusr->d,
991                                                   strlen (remusr->d),
992                                                   -1);
993                     rc=G10ERR_UNU_PUBKEY;
994                     goto fail;
995                 }
996                 else if( do_we_trust_pre( pk, trustlevel ) ) {
997                     /* note: do_we_trust may have changed the trustlevel */
998
999                     /* We have at least one valid recipient. It doesn't matters
1000                      * if this recipient is already present. */
1001                     any_recipients = 1;
1002
1003                     /* Skip the actual key if the key is already present
1004                      * in the list */
1005                     if (key_present_in_pk_list(pk_list, pk) == 0) {
1006                         free_public_key(pk); pk = NULL;
1007                         log_info(_("%s: skipped: public key already present\n"),
1008                                                                     remusr->d);
1009                     }
1010                     else {
1011                         PK_LIST r;
1012                         r = m_alloc( sizeof *r );
1013                         r->pk = pk; pk = NULL;
1014                         r->next = pk_list;
1015                         r->mark = 0;
1016                         pk_list = r;
1017                     }
1018                 }
1019                 else { /* we don't trust this pk */
1020                     free_public_key( pk ); pk = NULL;
1021                     write_status_text_and_buffer (STATUS_INV_RECP, "10 ",
1022                                                   remusr->d,
1023                                                   strlen (remusr->d),
1024                                                   -1);
1025                     rc=G10ERR_UNU_PUBKEY;
1026                     goto fail;
1027                 }
1028             }
1029             else {
1030                 free_public_key( pk ); pk = NULL;
1031                 write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
1032                                               remusr->d,
1033                                               strlen (remusr->d),
1034                                               -1);
1035                 log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
1036                 goto fail;
1037             }
1038         }
1039     }
1040
1041     if( !rc && !any_recipients ) {
1042         log_error(_("no valid addressees\n"));
1043         write_status_text (STATUS_NO_RECP, "0");
1044         rc = G10ERR_NO_USER_ID;
1045     }
1046
1047  fail:
1048
1049     if( rc )
1050         release_pk_list( pk_list );
1051     else
1052         *ret_pk_list = pk_list;
1053     if(opt.grouplist)
1054       free_strlist(remusr);
1055     return rc;
1056 }
1057
1058
1059 /* In pgp6 mode, disallow all ciphers except IDEA (1), 3DES (2), and
1060    CAST5 (3), all hashes except MD5 (1), SHA1 (2), and RIPEMD160 (3),
1061    and all compressions except none (0) and ZIP (1).  pgp7 mode
1062    expands the cipher list to include AES128 (7), AES192 (8), AES256
1063    (9), and TWOFISH (10).  For a true PGP key all of this is unneeded
1064    as they are the only items present in the preferences subpacket,
1065    but checking here covers the weird case of encrypting to a key that
1066    had preferences from a different implementation which was then used
1067    with PGP.  I am not completely comfortable with this as the right
1068    thing to do, as it slightly alters the list of what the user is
1069    supposedly requesting.  It is not against the RFC however, as the
1070    preference chosen will never be one that the user didn't specify
1071    somewhere ("The implementation may use any mechanism to pick an
1072    algorithm in the intersection"), and PGP has no mechanism to fix
1073    such a broken preference list, so I'm including it. -dms */
1074
1075 static int
1076 algo_available( int preftype, int algo, void *hint )
1077 {
1078     if( preftype == PREFTYPE_SYM ) {
1079         if( opt.pgp6 && ( algo != 1 && algo != 2 && algo != 3) )
1080           return 0;
1081
1082         if( opt.pgp7 && (algo != 1 && algo != 2 && algo != 3 &&
1083                          algo != 7 && algo != 8 && algo != 9 && algo != 10) )
1084           return 0;
1085
1086         return algo && !check_cipher_algo( algo );
1087     }
1088     else if( preftype == PREFTYPE_HASH ) {
1089         int bits=0;
1090
1091         if(hint)
1092           bits=*(int *)hint;
1093
1094         if(bits && (bits != md_digest_length(algo)))
1095           return 0;
1096
1097         if( (opt.pgp6 || opt.pgp7 ) && ( algo != 1 && algo != 2 && algo != 3) )
1098           return 0;
1099
1100         return algo && !check_digest_algo( algo );
1101     }
1102     else if( preftype == PREFTYPE_ZIP ) {
1103         if ( ( opt.pgp6 || opt.pgp7 ) && ( algo !=0 && algo != 1) )
1104           return 0;
1105
1106         return !check_compress_algo( algo );
1107     }
1108     else
1109         return 0;
1110 }
1111
1112
1113
1114 /****************
1115  * Return -1 if we could not find an algorithm.
1116  */
1117 int
1118 select_algo_from_prefs(PK_LIST pk_list, int preftype, int request, void *hint)
1119 {
1120     PK_LIST pkr;
1121     u32 bits[8];
1122     const prefitem_t *prefs;
1123     int i, j;
1124     int compr_hack=0;
1125     int any;
1126
1127     if( !pk_list )
1128         return -1;
1129
1130     memset( bits, ~0, 8 * sizeof *bits );
1131     for( pkr = pk_list; pkr; pkr = pkr->next ) {
1132         u32 mask[8];
1133
1134         memset( mask, 0, 8 * sizeof *mask );
1135         if( preftype == PREFTYPE_SYM ) {
1136           if( opt.pgp2 &&
1137               pkr->pk->version < 4 &&
1138               pkr->pk->selfsigversion < 4 )
1139             mask[0] |= (1<<1); /* IDEA is implicitly there for v3 keys
1140                                   with v3 selfsigs (rfc2440:12.1) if
1141                                   --pgp2 mode is on.  This doesn't
1142                                   mean it's actually available, of
1143                                   course. */
1144           else
1145             mask[0] |= (1<<2); /* 3DES is implicitly there for everyone else */
1146         }
1147         else if( preftype == PREFTYPE_HASH ) {
1148           /* While I am including this code for completeness, note
1149              that currently --pgp2 mode locks the hash at MD5, so this
1150              function will never even be called.  Even if the hash
1151              wasn't locked at MD5, we don't support sign+encrypt in
1152              --pgp2 mode, and that's the only time PREFTYPE_HASH is
1153              used anyway. -dms */
1154           if( opt.pgp2 &&
1155               pkr->pk->version < 4 &&
1156               pkr->pk->selfsigversion < 4 )
1157             mask[0] |= (1<<1); /* MD5 is there for v3 keys with v3
1158                                   selfsigs when --pgp2 is on. */
1159           else
1160             mask[0] |= (1<<2); /* SHA1 is there for everyone else */
1161         }
1162         else if( preftype == PREFTYPE_ZIP )
1163           mask[0] |= (1<<0); /* Uncompressed is implicit */
1164
1165         if (pkr->pk->user_id) /* selected by user ID */
1166             prefs = pkr->pk->user_id->prefs;
1167         else
1168             prefs = pkr->pk->prefs;
1169
1170         any = 0;
1171         if( prefs ) {
1172             for (i=0; prefs[i].type; i++ ) {
1173                 if( prefs[i].type == preftype ) {
1174                     mask[prefs[i].value/32] |= 1 << (prefs[i].value%32);
1175                     any = 1;
1176                 }
1177             }
1178         }
1179
1180         if( (!prefs || !any) && preftype == PREFTYPE_ZIP ) {
1181             mask[0] |= 3; /* asume no_compression and old pgp */
1182             compr_hack = 1;
1183         }
1184
1185       #if 0
1186         log_debug("pref mask=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
1187                (ulong)mask[7], (ulong)mask[6], (ulong)mask[5], (ulong)mask[4],
1188              (ulong)mask[3], (ulong)mask[2], (ulong)mask[1], (ulong)mask[0]);
1189       #endif
1190         for(i=0; i < 8; i++ )
1191             bits[i] &= mask[i];
1192       #if 0
1193         log_debug("pref bits=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
1194                (ulong)bits[7], (ulong)bits[6], (ulong)bits[5], (ulong)bits[4],
1195              (ulong)bits[3], (ulong)bits[2], (ulong)bits[1], (ulong)bits[0]);
1196       #endif
1197     }
1198     /* usable algorithms are now in bits
1199      * We now use the last key from pk_list to select
1200      * the algorithm we want to use. there are no
1201      * preferences for the last key, we select the one
1202      * corresponding to first set bit.
1203      */
1204     i = -1;
1205     any = 0;
1206
1207     /* Can we use the requested algorithm? */
1208     if(request>-1 && (bits[request/32] & (1<<(request%32))) &&
1209        algo_available(preftype,request,hint))
1210       return request;
1211
1212     /* If we have personal prefs set, use them instead of the last key */
1213     if(preftype==PREFTYPE_SYM && opt.personal_cipher_prefs)
1214       prefs=opt.personal_cipher_prefs;
1215     else if(preftype==PREFTYPE_HASH && opt.personal_digest_prefs)
1216       prefs=opt.personal_digest_prefs;
1217     else if(preftype==PREFTYPE_ZIP && opt.personal_compress_prefs)
1218       prefs=opt.personal_compress_prefs;
1219
1220     if( prefs ) {
1221         for(j=0; prefs[j].type; j++ ) {
1222             if( prefs[j].type == preftype ) {
1223                 if( (bits[prefs[j].value/32] & (1<<(prefs[j].value%32))) ) {
1224                     if( algo_available( preftype, prefs[j].value, hint ) ) {
1225                         any = 1;
1226                         i = prefs[j].value;
1227                         break;
1228                     }
1229                 }
1230             }
1231         }
1232     }
1233     if( !prefs || !any ) {
1234         for(j=0; j < 256; j++ )
1235             if( (bits[j/32] & (1<<(j%32))) ) {
1236                 if( algo_available( preftype, j, hint ) ) {
1237                     i = j;
1238                     break;
1239                 }
1240             }
1241     }
1242
1243   #if 0
1244     log_debug("prefs of type %d: selected %d\n", preftype, i );
1245   #endif
1246     if( compr_hack && !i ) {
1247         /* selected no compression, but we should check whether
1248          * algorithm 1 is also available (the ordering is not relevant
1249          * in this case). */
1250         if( bits[0] & (1<<1) )
1251             i = 1;  /* yep; we can use compression algo 1 */
1252     }
1253
1254     /* "If you are building an authentication system, the recipient
1255        may specify a preferred signing algorithm. However, the signer
1256        would be foolish to use a weak algorithm simply because the
1257        recipient requests it." RFC2440:13.  If we settle on MD5, and
1258        SHA1 is also available, use SHA1 instead.  Of course, if the
1259        user intentinally chose MD5 (by putting it in their personal
1260        prefs), then we should do what they say. */
1261
1262     if(preftype==PREFTYPE_HASH &&
1263        i==DIGEST_ALGO_MD5 && (bits[0] & (1<<DIGEST_ALGO_SHA1)))
1264       {
1265         i=DIGEST_ALGO_SHA1;
1266
1267         if(opt.personal_digest_prefs)
1268           for(j=0; prefs[j].type; j++ )
1269             if(opt.personal_digest_prefs[j].type==PREFTYPE_HASH &&
1270                opt.personal_digest_prefs[j].value==DIGEST_ALGO_MD5)
1271               {
1272                 i=DIGEST_ALGO_MD5;
1273                 break;
1274               }
1275       }
1276
1277     return i;
1278 }
1279
1280 /*
1281  * Select the MDC flag from the pk_list.  We can only use MDC if all recipients
1282  * support this feature 
1283  */
1284 int
1285 select_mdc_from_pklist (PK_LIST pk_list)
1286 {
1287     PK_LIST pkr;
1288
1289     if( !pk_list )
1290         return 0;
1291
1292     for (pkr = pk_list; pkr; pkr = pkr->next) {
1293         int mdc;
1294
1295         if (pkr->pk->user_id) /* selected by user ID */
1296             mdc = pkr->pk->user_id->mdc_feature;
1297         else
1298             mdc = pkr->pk->mdc_feature;
1299         if (!mdc)
1300             return 0; /* at least one recipient does not support it */
1301     }
1302     return 1; /* can be used */
1303 }