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