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