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