Implemented PKA trust model
[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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
20  * USA.
21  */
22
23 #include <config.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <errno.h>
28 #include <assert.h>
29
30 #include "options.h"
31 #include "packet.h"
32 #include "errors.h"
33 #include "keydb.h"
34 #include "memory.h"
35 #include "util.h"
36 #include "main.h"
37 #include "trustdb.h"
38 #include "ttyio.h"
39 #include "status.h"
40 #include "photoid.h"
41 #include "i18n.h"
42
43 #define CONTROL_D ('D' - 'A' + 1)
44
45 /****************
46  * Show the revocation reason as it is stored with the given signature
47  */
48 static void
49 do_show_revocation_reason( PKT_signature *sig )
50 {
51     size_t n, nn;
52     const byte *p, *pp;
53     int seq = 0;
54     const char *text;
55
56     while( (p = enum_sig_subpkt (sig->hashed, SIGSUBPKT_REVOC_REASON,
57                                  &n, &seq, NULL )) ) {
58         if( !n )
59             continue; /* invalid - just skip it */
60
61         if( *p == 0 )
62             text = _("No reason specified");
63         else if( *p == 0x01 )
64             text = _("Key is superseded");
65         else if( *p == 0x02 )
66             text = _("Key has been compromised");
67         else if( *p == 0x03 )
68             text = _("Key is no longer used");
69         else if( *p == 0x20 )
70             text = _("User ID is no longer valid");
71         else
72             text = NULL;
73
74         log_info( _("reason for revocation: ") );
75         if( text )
76             fputs( text, log_stream() );
77         else
78             fprintf( log_stream(), "code=%02x", *p );
79         putc( '\n', log_stream() );
80         n--; p++;
81         pp = NULL;
82         do {
83             /* We don't want any empty lines, so skip them */
84             while( n && *p == '\n' ) {
85                 p++;
86                 n--;
87             }
88             if( n ) {
89                 pp = memchr( p, '\n', n );
90                 nn = pp? pp - p : n;
91                 log_info( _("revocation comment: ") );
92                 print_string( log_stream(), p, nn, 0 );
93                 putc( '\n', log_stream() );
94                 p += nn; n -= nn;
95             }
96         } while( pp );
97     }
98 }
99
100 /* Mode 0: try and find the revocation based on the pk (i.e. check
101    subkeys, etc.)  Mode 1: use only the revocation on the main pk */
102
103 void
104 show_revocation_reason( PKT_public_key *pk, int mode )
105 {
106     /* Hmmm, this is not so easy becuase we have to duplicate the code
107      * used in the trustbd to calculate the keyflags.  We need to find
108      * a clean way to check revocation certificates on keys and
109      * signatures.  And there should be no duplicate code.  Because we
110      * enter this function only when the trustdb told us that we have
111      * a revoked key, we could simply look for a revocation cert and
112      * display this one, when there is only one. Let's try to do this
113      * until we have a better solution.  */
114     KBNODE node, keyblock = NULL;
115     byte fingerprint[MAX_FINGERPRINT_LEN];
116     size_t fingerlen;
117     int rc;
118
119     /* get the keyblock */
120     fingerprint_from_pk( pk, fingerprint, &fingerlen );
121     rc = get_keyblock_byfprint( &keyblock, fingerprint, fingerlen );
122     if( rc ) { /* that should never happen */
123         log_debug( "failed to get the keyblock\n");
124         return;
125     }
126
127     for( node=keyblock; node; node = node->next ) {
128         if( (mode && node->pkt->pkttype == PKT_PUBLIC_KEY) ||
129           ( ( node->pkt->pkttype == PKT_PUBLIC_KEY
130               || node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
131             && !cmp_public_keys( node->pkt->pkt.public_key, pk ) ) )
132             break;
133     }
134     if( !node ) {
135         log_debug("Oops, PK not in keyblock\n");
136         release_kbnode( keyblock );
137         return;
138     }
139     /* now find the revocation certificate */
140     for( node = node->next; node ; node = node->next ) {
141         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
142             break;
143         if( node->pkt->pkttype == PKT_SIGNATURE
144             && (node->pkt->pkt.signature->sig_class == 0x20
145                 || node->pkt->pkt.signature->sig_class == 0x28 ) ) {
146                 /* FIXME: we should check the signature here */
147                 do_show_revocation_reason ( node->pkt->pkt.signature );
148                 break;
149         }
150     }
151
152     /* We didn't find it, so check if the whole key is revoked */
153     if(!node && !mode)
154       show_revocation_reason(pk,1);
155
156     release_kbnode( keyblock );
157 }
158
159
160 /****************
161  * mode: 0 = standard
162  *       1 = Without key info and additional menu option 'm'
163  *           this does also add an option to set the key to ultimately trusted.
164  * Returns: 
165  *      -2 = nothing changed - caller should show some additional info
166  *      -1 = quit operation
167  *       0 = nothing changed
168  *       1 = new ownertrust now in new_trust
169  */
170 static int
171 do_edit_ownertrust (PKT_public_key *pk, int mode,
172                     unsigned *new_trust, int defer_help )
173 {
174   char *p;
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
196        Note to translators: These are the allowed answers in lower and
197        uppercase.  Below you will find the matching strings which
198        should be translated accordingly and the letter changed to
199        match the one in the answer string.
200     
201          i = please show me more information
202          m = back to the main menu
203          s = skip this key
204          q = quit
205     */
206     const char *ans = _("iImMqQsS");
207
208     if( !did_help ) 
209       {
210         if( !mode ) 
211           {
212             KBNODE keyblock, un;
213
214             tty_printf(_("No trust value assigned to:\n"));
215             tty_printf("%4u%c/%s %s\n",nbits_from_pk( pk ),
216                        pubkey_letter( pk->pubkey_algo ),
217                        keystr(keyid), datestr_from_pk( pk ) );
218             p=get_user_id_native(keyid);
219             tty_printf(_("      \"%s\"\n"),p);
220             xfree(p);
221
222             keyblock = get_pubkeyblock (keyid);
223             if (!keyblock)
224                 BUG ();
225             for (un=keyblock; un; un = un->next)
226               {
227                 if (un->pkt->pkttype != PKT_USER_ID )
228                   continue;
229                 if (un->pkt->pkt.user_id->is_revoked )
230                   continue;
231                 if (un->pkt->pkt.user_id->is_expired )
232                   continue;
233                 /* Only skip textual primaries */
234                 if (un->pkt->pkt.user_id->is_primary
235                     && !un->pkt->pkt.user_id->attrib_data )
236                   continue;
237                 
238                 if((opt.verify_options&VERIFY_SHOW_PHOTOS)
239                    && un->pkt->pkt.user_id->attrib_data)
240                   show_photos(un->pkt->pkt.user_id->attribs,
241                               un->pkt->pkt.user_id->numattribs,pk,NULL);
242
243                 p=utf8_to_native(un->pkt->pkt.user_id->name,
244                                  un->pkt->pkt.user_id->len,0);
245
246                 tty_printf(_("  aka \"%s\"\n"),p);
247               }
248         
249             print_fingerprint (pk, NULL, 2);
250             tty_printf("\n");
251             release_kbnode (keyblock);
252           }
253
254         if(opt.trust_model==TM_DIRECT)
255           {
256             tty_printf(_("How much do you trust that this key actually "
257                          "belongs to the named user?\n"));
258             tty_printf("\n");
259           }
260         else
261           {
262             /* This string also used in keyedit.c:trustsig_prompt */
263             tty_printf(_("Please decide how far you trust this user to"
264                          " correctly verify other users' keys\n"
265                          "(by looking at passports, checking fingerprints from"
266                          " different sources, etc.)\n"));
267             tty_printf("\n");
268           }
269
270         if(min_num<=1)
271           tty_printf (_("  %d = I don't know or won't say\n"), 1);
272         if(min_num<=2)
273           tty_printf (_("  %d = I do NOT trust\n"), 2);
274         if(min_num<=3)
275           tty_printf (_("  %d = I trust marginally\n"), 3);
276         if(min_num<=4)
277           tty_printf (_("  %d = I trust fully\n"), 4);
278         if (mode)
279           tty_printf (_("  %d = I trust ultimately\n"), 5);
280 #if 0
281         /* not yet implemented */
282         tty_printf ("  i = please show me more information\n");
283 #endif
284         if( mode )
285           tty_printf(_("  m = back to the main menu\n"));
286         else
287           {
288             tty_printf(_("  s = skip this key\n"));
289             tty_printf(_("  q = quit\n"));
290           }
291         tty_printf("\n");
292         if(minimum)
293           tty_printf(_("The minimum trust level for this key is: %s\n\n"),
294                      trust_value_to_string(minimum));
295         did_help = 1;
296       }
297     if( strlen(ans) != 8 )
298       BUG();
299     p = cpr_get("edit_ownertrust.value",_("Your decision? "));
300     trim_spaces(p);
301     cpr_kill_prompt();
302     if( !*p )
303       did_help = 0;
304     else if( *p && p[1] )
305       ;
306     else if( !p[1] && ((*p >= '0'+min_num) && *p <= (mode?'5':'4')) ) 
307       {
308         unsigned int trust;
309         switch( *p )
310           {
311           case '1': trust = TRUST_UNDEFINED; break;
312           case '2': trust = TRUST_NEVER    ; break;
313           case '3': trust = TRUST_MARGINAL ; break;
314           case '4': trust = TRUST_FULLY    ; break;
315           case '5': trust = TRUST_ULTIMATE ; break;
316           default: BUG();
317           }
318         if (trust == TRUST_ULTIMATE
319             && !cpr_get_answer_is_yes ("edit_ownertrust.set_ultimate.okay",
320                                        _("Do you really want to set this key"
321                                          " to ultimate trust? (y/N) ")))
322           ; /* no */
323         else
324           {
325             *new_trust = trust;
326             changed = 1;
327             break;
328           }
329       }
330 #if 0
331     /* not yet implemented */
332     else if( *p == ans[0] || *p == ans[1] ) 
333       {
334         tty_printf(_("Certificates leading to an ultimately trusted key:\n"));
335         show = 1;
336         break;
337       }
338 #endif
339     else if( mode && (*p == ans[2] || *p == ans[3] || *p == CONTROL_D ) ) 
340       {
341         break ; /* back to the menu */
342       }
343     else if( !mode && (*p == ans[6] || *p == ans[7] ) )
344       {
345         break; /* skip */
346       }
347     else if( !mode && (*p == ans[4] || *p == ans[5] ) )
348       {
349         quit = 1;
350         break ; /* back to the menu */
351       }
352     xfree(p); p = NULL;
353   }
354   xfree(p);
355   return show? -2: quit? -1 : changed;
356 }
357
358 /* 
359  * Display a menu to change the ownertrust of the key PK (which should
360  * be a primary key).  
361  * For mode values see do_edit_ownertrust ()
362  */
363 int
364 edit_ownertrust (PKT_public_key *pk, int mode )
365 {
366   unsigned int trust;
367   int no_help = 0;
368
369   for(;;)
370     {
371       switch ( do_edit_ownertrust (pk, mode, &trust, no_help ) )
372         {
373         case -1: /* quit */
374           return -1;
375         case -2: /* show info */
376           no_help = 1;
377           break;
378         case 1: /* trust value set */
379           trust &= ~TRUST_FLAG_DISABLED;
380           trust |= get_ownertrust (pk) & TRUST_FLAG_DISABLED;
381           update_ownertrust (pk, trust );
382           return 1;
383         default:
384           return 0;
385         }
386     }
387 }
388
389
390 /****************
391  * Check whether we can trust this pk which has a trustlevel of TRUSTLEVEL
392  * Returns: true if we trust.
393  */
394 static int
395 do_we_trust( PKT_public_key *pk, unsigned int trustlevel )
396 {
397   /* We should not be able to get here with a revoked or expired
398      key */
399   if(trustlevel & TRUST_FLAG_REVOKED
400      || trustlevel & TRUST_FLAG_SUB_REVOKED
401      || (trustlevel & TRUST_MASK) == TRUST_EXPIRED)
402     BUG();
403
404   if( opt.trust_model==TM_ALWAYS )
405     {
406       if( opt.verbose )
407         log_info("No trust check due to `--trust-model always' option\n");
408       return 1;
409     }
410
411   switch(trustlevel & TRUST_MASK)
412     {
413     default:
414       log_error ("invalid trustlevel %u returned from validation layer\n",
415                  trustlevel);
416       /* fall thru */
417     case TRUST_UNKNOWN: 
418     case TRUST_UNDEFINED:
419       log_info(_("%s: There is no assurance this key belongs"
420                  " to the named user\n"),keystr_from_pk(pk));
421       return 0; /* no */
422
423     case TRUST_MARGINAL:
424       log_info(_("%s: There is limited assurance this key belongs"
425                  " to the named user\n"),keystr_from_pk(pk));
426       return 1; /* yes */
427
428     case TRUST_FULLY:
429       if( opt.verbose )
430         log_info(_("This key probably belongs to the named user\n"));
431       return 1; /* yes */
432
433     case TRUST_ULTIMATE:
434       if( opt.verbose )
435         log_info(_("This key belongs to us\n"));
436       return 1; /* yes */
437     }
438
439   return 1; /* yes */
440 }
441
442
443 /****************
444  * wrapper around do_we_trust, so we can ask whether to use the
445  * key anyway.
446  */
447 static int
448 do_we_trust_pre( PKT_public_key *pk, unsigned int trustlevel )
449 {
450   int rc;
451
452   rc = do_we_trust( pk, trustlevel );
453
454   if( !opt.batch && !rc )
455     {
456       print_pubkey_info(NULL,pk);
457       print_fingerprint (pk, NULL, 2);
458       tty_printf("\n");
459
460       tty_printf(
461                _("It is NOT certain that the key belongs to the person named\n"
462                  "in the user ID.  If you *really* know what you are doing,\n"
463                  "you may answer the next question with yes.\n"));
464
465       tty_printf("\n");
466
467       if( cpr_get_answer_is_yes("untrusted_key.override",
468                                 _("Use this key anyway? (y/N) "))  )
469         rc = 1;
470
471       /* Hmmm: Should we set a flag to tell the user about
472        *         his decision the next time he encrypts for this recipient?
473        */
474     }
475
476   return rc;
477 }
478
479
480 /****************
481  * Check whether we can trust this signature.
482  * Returns: Error if we shall not trust this signatures.
483  */
484 int
485 check_signatures_trust( PKT_signature *sig )
486 {
487   PKT_public_key *pk = xmalloc_clear( sizeof *pk );
488   unsigned int trustlevel;
489   int rc=0;
490
491   rc = get_pubkey( pk, sig->keyid );
492   if (rc) 
493     { /* this should not happen */
494       log_error("Ooops; the key vanished  - can't check the trust\n");
495       rc = G10ERR_NO_PUBKEY;
496       goto leave;
497     }
498
499   if ( opt.trust_model==TM_ALWAYS )
500     {
501       if( !opt.quiet )
502         log_info(_("WARNING: Using untrusted key!\n"));
503       if (opt.with_fingerprint)
504         print_fingerprint (pk, NULL, 1);
505       goto leave;
506     }
507
508   if(pk->maybe_revoked && !pk->is_revoked)
509     log_info(_("WARNING: this key might be revoked (revocation key"
510                " not present)\n"));
511
512   trustlevel = get_validity (pk, NULL);
513
514   if ( (trustlevel & TRUST_FLAG_REVOKED) ) 
515     {
516       write_status( STATUS_KEYREVOKED );
517       if(pk->is_revoked==2)
518         log_info(_("WARNING: This key has been revoked by its"
519                    " designated revoker!\n"));
520       else
521         log_info(_("WARNING: This key has been revoked by its owner!\n"));
522       log_info(_("         This could mean that the signature is forged.\n"));
523       show_revocation_reason( pk, 0 );
524     }
525   else if ((trustlevel & TRUST_FLAG_SUB_REVOKED) ) 
526     {
527       write_status( STATUS_KEYREVOKED );
528       log_info(_("WARNING: This subkey has been revoked by its owner!\n"));
529       show_revocation_reason( pk, 0 );
530     }
531   
532   if ((trustlevel & TRUST_FLAG_DISABLED))
533     log_info (_("Note: This key has been disabled.\n"));
534
535   /* If we have PKA information adjust the trustlevel. */
536   if (sig->pka_info && sig->pka_info->valid)
537     {
538       unsigned char fpr[MAX_FINGERPRINT_LEN];
539       PKT_public_key *primary_pk;
540       size_t fprlen;
541       int okay;
542
543       log_info (_("Note: Verified address is `%s'\n"), sig->pka_info->email);
544
545       primary_pk = xmalloc_clear (sizeof *primary_pk);
546       get_pubkey (primary_pk, pk->main_keyid);
547       fingerprint_from_pk (primary_pk, fpr, &fprlen);
548       free_public_key (primary_pk);
549
550       if ( fprlen == 20 && !memcmp (sig->pka_info->fpr, fpr, 20) )
551         okay = 1;
552       else
553         okay = 0;
554
555       switch ( (trustlevel & TRUST_MASK) ) 
556         {
557         case TRUST_UNKNOWN: 
558         case TRUST_UNDEFINED:
559         case TRUST_MARGINAL:
560           if (okay)
561             {
562               trustlevel = ((trustlevel & ~TRUST_MASK) | TRUST_FULLY);
563               log_info ("trustlevel adjusted to FULL due to valid PKA info\n");
564             }
565           /* (fall through) */
566         case TRUST_FULLY:
567           if (!okay)
568             {
569               trustlevel = ((trustlevel & ~TRUST_MASK) | TRUST_NEVER);
570               log_info ("trustlevel adjusted to NEVER due to bad PKA info\n");
571             }
572           break;
573         }
574     }
575
576   /* Now let the user know what up with the trustlevel. */
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         xfree( 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 xstrdup( opt.def_recipient );
674     if( !opt.def_recipient_self )
675         return NULL;
676     sk = xmalloc_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 = xmalloc( 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 = xmalloc_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 = xmalloc( 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             xfree(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/%s %s \"",
852                                nbits_from_pk(iter->pk),
853                                pubkey_letter(iter->pk->pubkey_algo),
854                                keystr(keyid),
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                         xfree(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                 xfree(answer);
877                 break;
878             }
879             if(expand_id(answer,&backlog,0))
880               continue;
881             if( pk )
882                 free_public_key( pk );
883             pk = xmalloc_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 = xmalloc( 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 = xmalloc( 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             xfree(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 = xmalloc_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 = xmalloc( 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         xfree(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 = xmalloc_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 = xmalloc( 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 }