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