See ChangeLog: Fri Sep 3 10:06:06 CEST 1999 Werner Koch
[gnupg.git] / g10 / pkclist.c
1 /* pkclist.c
2  *      Copyright (C) 1998 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 "trustdb.h"
35 #include "ttyio.h"
36 #include "status.h"
37 #include "i18n.h"
38
39
40 #define CONTROL_D ('D' - 'A' + 1)
41
42 /* fixme: we have nearly the same code in keyedit.c */
43 static void
44 print_fpr( PKT_public_key *pk )
45 {
46     byte array[MAX_FINGERPRINT_LEN], *p;
47     size_t i, n;
48
49     fingerprint_from_pk( pk, array, &n );
50     p = array;
51     /* Translators: this shoud fit into 24 bytes to that the fingerprint
52      * data is properly aligned with the user ID */
53     tty_printf(_("             Fingerprint:"));
54     if( n == 20 ) {
55         for(i=0; i < n ; i++, i++, p += 2 ) {
56             if( i == 10 )
57                 tty_printf(" ");
58             tty_printf(" %02X%02X", *p, p[1] );
59         }
60     }
61     else {
62         for(i=0; i < n ; i++, p++ ) {
63             if( i && !(i%8) )
64                 tty_printf(" ");
65             tty_printf(" %02X", *p );
66         }
67     }
68     tty_printf("\n");
69 }
70
71 static void
72 fpr_info( PKT_public_key *pk )
73 {
74     byte array[MAX_FINGERPRINT_LEN], *p;
75     size_t i, n;
76     FILE *fp = log_stream();
77
78     fingerprint_from_pk( pk, array, &n );
79     p = array;
80     log_info(_("Fingerprint:"));
81     if( n == 20 ) {
82         for(i=0; i < n ; i++, i++, p += 2 ) {
83             if( i == 10 )
84                 putc(' ', fp);
85             fprintf(fp, " %02X%02X", *p, p[1] );
86         }
87     }
88     else {
89         for(i=0; i < n ; i++, p++ ) {
90             if( i && !(i%8) )
91                 putc(' ', fp);
92             fprintf(fp, " %02X", *p );
93         }
94     }
95     putc('\n', fp );
96 }
97
98
99
100 static void
101 show_paths( ulong lid, int only_first )
102 {
103     void *context = NULL;
104     unsigned otrust, validity;
105     int last_level, level;
106
107     last_level = 0;
108     while( (level=enum_cert_paths( &context, &lid, &otrust, &validity)) != -1){
109         char *p;
110         int c, rc;
111         size_t n;
112         u32 keyid[2];
113         PKT_public_key *pk ;
114
115         if( level < last_level && only_first )
116             break;
117         last_level = level;
118
119         rc = keyid_from_lid( lid, keyid );
120         if( rc ) {
121             log_error("ooops: can't get keyid for lid %lu\n", lid);
122             return;
123         }
124
125         pk = m_alloc_clear( sizeof *pk );
126         rc = get_pubkey( pk, keyid );
127         if( rc ) {
128             log_error("key %08lX: public key not found: %s\n",
129                                     (ulong)keyid[1], g10_errstr(rc) );
130             return;
131         }
132
133         tty_printf("%*s%4u%c/%08lX.%lu %s \"",
134                   level*2, "",
135                   nbits_from_pk( pk ), pubkey_letter( pk->pubkey_algo ),
136                   (ulong)keyid[1], lid, datestr_from_pk( pk ) );
137
138         c = trust_letter(otrust);
139         if( c )
140             putchar( c );
141         else
142             printf( "%02x", otrust );
143         putchar('/');
144         c = trust_letter(validity);
145         if( c )
146             putchar( c );
147         else
148             printf( "%02x", validity );
149         putchar(' ');
150
151         p = get_user_id( keyid, &n );
152         tty_print_string( p, n ),
153         m_free(p);
154         tty_printf("\"\n");
155         free_public_key( pk );
156     }
157     enum_cert_paths( &context, NULL, NULL, NULL ); /* release context */
158     tty_printf("\n");
159 }
160
161
162
163
164 /****************
165  * Returns true if an ownertrust has changed.
166  */
167 static int
168 do_edit_ownertrust( ulong lid, int mode, unsigned *new_trust, int defer_help )
169 {
170     char *p;
171     int rc;
172     size_t n;
173     u32 keyid[2];
174     PKT_public_key *pk ;
175     int changed=0;
176     int quit=0;
177     int show=0;
178     int did_help=defer_help;
179
180     rc = keyid_from_lid( lid, keyid );
181     if( rc ) {
182         log_error("ooops: can't get keyid for lid %lu\n", lid);
183         return 0;
184     }
185
186     pk = m_alloc_clear( sizeof *pk );
187     rc = get_pubkey( pk, keyid );
188     if( rc ) {
189         log_error("key %08lX: public key not found: %s\n",
190                                 (ulong)keyid[1], g10_errstr(rc) );
191         return 0;
192     }
193
194
195     for(;;) {
196         /* a string with valid answers */
197         char *ans = _("sSmMqQ");
198
199         if( !did_help ) {
200             if( !mode ) {
201                 tty_printf(_("No trust value assigned to %lu:\n"
202                            "%4u%c/%08lX %s \""), lid,
203                           nbits_from_pk( pk ), pubkey_letter( pk->pubkey_algo ),
204                           (ulong)keyid[1], datestr_from_pk( pk ) );
205                 p = get_user_id( keyid, &n );
206                 tty_print_string( p, n ),
207                 m_free(p);
208                 tty_printf("\"\n");
209                 print_fpr( pk );
210                 tty_printf("\n");
211             }
212             tty_printf(_(
213 "Please decide how far you trust this user to correctly\n"
214 "verify other users' keys (by looking at passports,\n"
215 "checking fingerprints from different sources...)?\n\n"
216 " 1 = Don't know\n"
217 " 2 = I do NOT trust\n"
218 " 3 = I trust marginally\n"
219 " 4 = I trust fully\n"
220 " s = please show me more information\n") );
221             if( mode )
222                 tty_printf(_(" m = back to the main menu\n"));
223             else
224                 tty_printf(_(" q = quit\n"));
225             tty_printf("\n");
226             did_help = 1;
227         }
228         if( strlen(ans) != 6 )
229             BUG();
230         p = cpr_get("edit_ownertrust.value",_("Your decision? "));
231         trim_spaces(p);
232         cpr_kill_prompt();
233         if( !*p )
234             did_help = 0;
235         else if( *p && p[1] )
236             ;
237         else if( !p[1] && (*p >= '1' && *p <= '4') ) {
238             unsigned trust;
239             switch( *p ) {
240               case '1': trust = TRUST_UNDEFINED; break;
241               case '2': trust = TRUST_NEVER    ; break;
242               case '3': trust = TRUST_MARGINAL ; break;
243               case '4': trust = TRUST_FULLY    ; break;
244               default: BUG();
245             }
246             *new_trust = trust;
247             changed = 1;
248             break;
249         }
250         else if( *p == ans[0] || *p == ans[1] ) {
251             tty_printf(_(
252                 "Certificates leading to an ultimately trusted key:\n"));
253             show = 1;
254             break;
255         }
256         else if( mode && (*p == ans[2] || *p == ans[3] || *p == CONTROL_D ) ) {
257             break ; /* back to the menu */
258         }
259         else if( !mode && (*p == ans[4] || *p == ans[5] ) ) {
260             quit = 1;
261             break ; /* back to the menu */
262         }
263         m_free(p); p = NULL;
264     }
265     m_free(p);
266     m_free(pk);
267     return show? -2: quit? -1 : changed;
268 }
269
270
271 int
272 edit_ownertrust( ulong lid, int mode )
273 {
274     unsigned int trust;
275     int no_help = 0;
276
277     for(;;) {
278         switch( do_edit_ownertrust( lid, mode, &trust, no_help ) ) {
279           case -1:
280             return 0;
281           case -2:
282             show_paths( lid, 1  );
283             no_help = 1;
284             break;
285           case 1:
286             trust &= ~TRUST_FLAG_DISABLED;
287             trust |= get_ownertrust( lid ) & TRUST_FLAG_DISABLED;
288             if( !update_ownertrust( lid, trust ) )
289                 return 1;
290             return 0;
291           default:
292             return 0;
293         }
294     }
295 }
296
297 static int
298 add_ownertrust_cb( ulong lid )
299 {
300     unsigned trust;
301     int rc = do_edit_ownertrust( lid, 0, &trust, 0 );
302
303     if( rc == 1 )
304         return trust & TRUST_MASK;
305     return rc > 0? 0 : rc;
306 }
307
308 /****************
309  * Try to add some more owner trusts (interactive)
310  * This function presents all the signator in a certificate
311  * chain who have no ownertrust value assigned.
312  * Returns: -1 if no ownertrust were added.
313  */
314 static int
315 add_ownertrust( PKT_public_key *pk, int *quit, unsigned *trustlevel )
316 {
317     int rc;
318     unsigned flags = 0;
319
320     *quit = 0;
321     *trustlevel = 0;
322     tty_printf(
323 _("Could not find a valid trust path to the key.  Let's see whether we\n"
324   "can assign some missing owner trust values.\n\n"));
325
326     rc = check_trust( pk, trustlevel, NULL, add_ownertrust_cb, &flags );
327
328     if( !(flags & 1) )
329         tty_printf(_("No path leading to one of our keys found.\n\n") );
330     else if( !(flags & 2) )
331         tty_printf(_("No certificates with undefined trust found.\n\n") );
332     else if( !(flags & 4) )
333         tty_printf(_("No trust values changed.\n\n") );
334
335     return (flags & 4)? 0:-1;
336 }
337
338 /****************
339  * Check whether we can trust this pk which has a trustlevel of TRUSTLEVEL
340  * Returns: true if we trust.
341  */
342 static int
343 do_we_trust( PKT_public_key *pk, int trustlevel )
344 {
345     int rc;
346     int did_add = 0;
347
348   retry:
349     if( (trustlevel & TRUST_FLAG_REVOKED) ) {
350         log_info(_("key %08lX: key has been revoked!\n"),
351                                         (ulong)keyid_from_pk( pk, NULL) );
352         if( opt.batch )
353             return 0;
354
355         if( !cpr_get_answer_is_yes("revoked_key.override",
356                                     _("Use this key anyway? ")) )
357             return 0;
358     }
359     else if( (trustlevel & TRUST_FLAG_SUB_REVOKED) ) {
360         log_info(_("key %08lX: subkey has been revoked!\n"),
361                                         (ulong)keyid_from_pk( pk, NULL) );
362         if( opt.batch )
363             return 0;
364
365         if( !cpr_get_answer_is_yes("revoked_key.override",
366                                     _("Use this key anyway? ")) )
367             return 0;
368     }
369
370
371     switch( (trustlevel & TRUST_MASK) ) {
372       case TRUST_UNKNOWN: /* No pubkey in trustDB: Insert and check again */
373         rc = insert_trust_record_by_pk( pk );
374         if( rc ) {
375             log_error("failed to insert it into the trustdb: %s\n",
376                                                       g10_errstr(rc) );
377             return 0; /* no */
378         }
379         rc = check_trust( pk, &trustlevel, NULL, NULL, NULL );
380         if( rc )
381             log_fatal("trust check after insert failed: %s\n",
382                                                       g10_errstr(rc) );
383         if( trustlevel == TRUST_UNKNOWN || trustlevel == TRUST_EXPIRED ) {
384             log_debug("do_we_trust: oops at %d\n", __LINE__ );
385             return 0;
386         }
387         return do_we_trust( pk, trustlevel );
388
389       case TRUST_EXPIRED:
390         log_info(_("%08lX: key has expired\n"),
391                                     (ulong)keyid_from_pk( pk, NULL) );
392         return 0; /* no */
393
394       case TRUST_UNDEFINED:
395         if( opt.batch || opt.answer_no )
396             log_info(_("%08lX: no info to calculate a trust probability\n"),
397                                         (ulong)keyid_from_pk( pk, NULL) );
398         else {
399             int quit;
400
401             rc = add_ownertrust( pk, &quit, &trustlevel );
402             if( !rc && !did_add && !quit ) {
403                 did_add = 1;
404                 goto retry;
405             }
406         }
407         return 0;
408
409       case TRUST_NEVER:
410         log_info(_("%08lX: We do NOT trust this key\n"),
411                                         (ulong)keyid_from_pk( pk, NULL) );
412         return 0; /* no */
413
414       case TRUST_MARGINAL:
415         log_info(
416        _("%08lX: It is not sure that this key really belongs to the owner\n"
417          "but it is accepted anyway\n"), (ulong)keyid_from_pk( pk, NULL) );
418         return 1; /* yes */
419
420       case TRUST_FULLY:
421         if( opt.verbose )
422             log_info(_("This key probably belongs to the owner\n"));
423         return 1; /* yes */
424
425       case TRUST_ULTIMATE:
426         if( opt.verbose )
427             log_info(_("This key belongs to us\n"));
428         return 1; /* yes */
429
430       default: BUG();
431     }
432
433     return 1; /* yes */
434 }
435
436
437
438 /****************
439  * wrapper around do_we_trust, so we can ask whether to use the
440  * key anyway.
441  */
442 static int
443 do_we_trust_pre( PKT_public_key *pk, int trustlevel )
444 {
445     int rc;
446
447     rc = do_we_trust( pk, trustlevel );
448
449     if( (trustlevel & TRUST_FLAG_REVOKED) && !rc )
450         return 0;
451     if( (trustlevel & TRUST_FLAG_SUB_REVOKED) && !rc )
452         return 0;
453     else if( !opt.batch && !rc ) {
454         char *p;
455         u32 keyid[2];
456         size_t n;
457
458         keyid_from_pk( pk, keyid);
459         tty_printf( "%4u%c/%08lX %s \"",
460                   nbits_from_pk( pk ), pubkey_letter( pk->pubkey_algo ),
461                   (ulong)keyid[1], datestr_from_pk( pk ) );
462         p = get_user_id( keyid, &n );
463         tty_print_string( p, n ),
464         m_free(p);
465         tty_printf("\"\n");
466         print_fpr( pk );
467         tty_printf("\n");
468
469         tty_printf(_(
470 "It is NOT certain that the key belongs to its owner.\n"
471 "If you *really* know what you are doing, you may answer\n"
472 "the next question with yes\n\n") );
473
474         if( cpr_get_answer_is_yes("untrusted_key.override",
475                                   _("Use this key anyway? "))  )
476             rc = 1;
477
478         /* Hmmm: Should we set a flag to tell the user the user about
479          *       his decision the next time he encrypts for this recipient?
480          */
481     }
482     else if( opt.always_trust && !rc ) {
483         if( !opt.quiet )
484             log_info(_("WARNING: Using untrusted key!\n"));
485         rc = 1;
486     }
487     return rc;
488 }
489
490
491
492 /****************
493  * Check whether we can trust this signature.
494  * Returns: Error if we shall not trust this signatures.
495  */
496 int
497 check_signatures_trust( PKT_signature *sig )
498 {
499     PKT_public_key *pk = m_alloc_clear( sizeof *pk );
500     int trustlevel;
501     int did_add = 0;
502     int rc=0;
503
504
505     if( opt.always_trust ) {
506         if( !opt.quiet )
507             log_info(_("WARNING: Using untrusted key!\n"));
508         return 0;
509     }
510
511
512     rc = get_pubkey( pk, sig->keyid );
513     if( rc ) { /* this should not happen */
514         log_error("Ooops; the key vanished  - can't check the trust\n");
515         rc = G10ERR_NO_PUBKEY;
516         goto leave;
517     }
518
519     rc = check_trust( pk, &trustlevel, NULL, NULL, NULL );
520     if( rc ) {
521         log_error("check trust failed: %s\n", g10_errstr(rc));
522         goto leave;
523     }
524
525   retry:
526     if( (trustlevel & TRUST_FLAG_REVOKED) ) {
527         write_status( STATUS_KEYREVOKED );
528         log_info(_("WARNING: This key has been revoked by its owner!\n"));
529         log_info(_("         This could mean that the signature is forgery.\n"));
530     }
531     else if( (trustlevel & TRUST_FLAG_SUB_REVOKED) ) {
532         write_status( STATUS_KEYREVOKED );
533         log_info(_("WARNING: This subkey has been revoked by its owner!\n"));
534     }
535
536
537     switch( (trustlevel & TRUST_MASK) ) {
538       case TRUST_UNKNOWN: /* No pubkey in trustDB: Insert and check again */
539         rc = insert_trust_record_by_pk( pk );
540         if( rc ) {
541             log_error("failed to insert it into the trustdb: %s\n",
542                                                       g10_errstr(rc) );
543             goto leave;
544         }
545         rc = check_trust( pk, &trustlevel, NULL, NULL, NULL );
546         if( rc )
547             log_fatal("trust check after insert failed: %s\n",
548                                                       g10_errstr(rc) );
549         if( trustlevel == TRUST_UNKNOWN || trustlevel == TRUST_EXPIRED )
550             BUG();
551         goto retry;
552
553       case TRUST_EXPIRED:
554         log_info(_("Note: This key has expired!\n"));
555         fpr_info( pk );
556         break;
557
558       case TRUST_UNDEFINED:
559         if( did_add || opt.batch || opt.answer_no ) {
560             write_status( STATUS_TRUST_UNDEFINED );
561             log_info(_(
562             "WARNING: This key is not certified with a trusted signature!\n"));
563             log_info(_(
564             "         There is no indication that the "
565                                     "signature belongs to the owner.\n" ));
566             fpr_info( pk );
567         }
568         else {
569             int quit;
570             rc = add_ownertrust( pk, &quit, &trustlevel );
571             if( rc || quit ) {
572                 did_add = 1;
573                 rc = 0;
574             }
575             goto retry;
576         }
577         break;
578
579       case TRUST_NEVER:
580         write_status( STATUS_TRUST_NEVER );
581         log_info(_("WARNING: We do NOT trust this key!\n"));
582         log_info(_("         The signature is probably a FORGERY.\n"));
583         rc = G10ERR_BAD_SIGN;
584         break;
585
586       case TRUST_MARGINAL:
587         write_status( STATUS_TRUST_MARGINAL );
588         log_info(_(
589          "WARNING: This key is not certified with sufficiently trusted signatures!\n"
590                 ));
591         log_info(_(
592          "         It is not certain that the signature belongs to the owner.\n"
593                  ));
594         fpr_info( pk );
595         break;
596
597       case TRUST_FULLY:
598         write_status( STATUS_TRUST_FULLY );
599         break;
600
601       case TRUST_ULTIMATE:
602         write_status( STATUS_TRUST_ULTIMATE );
603         break;
604
605       default: BUG();
606     }
607
608
609   leave:
610     free_public_key( pk );
611     return rc;
612 }
613
614
615 void
616 release_pk_list( PK_LIST pk_list )
617 {
618     PK_LIST pk_rover;
619
620     for( ; pk_list; pk_list = pk_rover ) {
621         pk_rover = pk_list->next;
622         free_public_key( pk_list->pk );
623         m_free( pk_list );
624     }
625 }
626
627
628 static int
629 key_present_in_pk_list(PK_LIST pk_list, PKT_public_key *pk)
630 {
631     for( ; pk_list; pk_list = pk_list->next)
632         if (cmp_public_keys(pk_list->pk, pk) == 0)
633             return 0;
634
635     return -1;
636 }
637
638
639 /****************
640  * Return a malloced string with a default reciepient if there is any
641  */
642 static char *
643 default_recipient(void)
644 {
645     PKT_secret_key *sk;
646     byte fpr[MAX_FINGERPRINT_LEN+1];
647     size_t n;
648     char *p;
649     int i;
650
651     if( opt.def_recipient )
652         return m_strdup( opt.def_recipient );
653     if( !opt.def_recipient_self )
654         return NULL;
655     sk = m_alloc_clear( sizeof *sk );
656     i = get_seckey_byname( sk, NULL, 0 );
657     if( i ) {
658         free_secret_key( sk );
659         return NULL;
660     }
661     n = MAX_FINGERPRINT_LEN;
662     fingerprint_from_sk( sk, fpr, &n );
663     free_secret_key( sk );
664     p = m_alloc( 2*n+3 );
665     *p++ = '0';
666     *p++ = 'x';
667     for(i=0; i < n; i++ )
668         sprintf( p+2*i, "%02X", fpr[i] );
669     p -= 2;
670     return p;
671 }
672
673
674 int
675 build_pk_list( STRLIST remusr, PK_LIST *ret_pk_list, unsigned use )
676 {
677     PK_LIST pk_list = NULL;
678     PKT_public_key *pk=NULL;
679     int rc=0;
680     int any_recipients=0;
681     STRLIST rov;
682     char *def_rec = NULL;
683
684     /* check whether there are any recipients in the list and build the
685      * list of the encrypt-to ones (we always trust them) */
686     for( rov = remusr; rov; rov = rov->next ) {
687         if( !(rov->flags & 1) )
688             any_recipients = 1;
689         else if( (use & PUBKEY_USAGE_ENC) && !opt.no_encrypt_to ) {
690             pk = m_alloc_clear( sizeof *pk );
691             pk->pubkey_usage = use;
692             if( (rc = get_pubkey_byname( NULL, pk, rov->d, NULL )) ) {
693                 free_public_key( pk ); pk = NULL;
694                 log_error(_("%s: skipped: %s\n"), rov->d, g10_errstr(rc) );
695             }
696             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use )) ) {
697
698                 /* Skip the actual key if the key is already present
699                  * in the list */
700                 if (key_present_in_pk_list(pk_list, pk) == 0) {
701                     free_public_key(pk); pk = NULL;
702                     log_info(_("%s: skipped: public key already present\n"),
703                                                             rov->d);
704                 }
705                 else {
706                     PK_LIST r;
707                     r = m_alloc( sizeof *r );
708                     r->pk = pk; pk = NULL;
709                     r->next = pk_list;
710                     r->mark = 0;
711                     pk_list = r;
712                 }
713             }
714             else {
715                 free_public_key( pk ); pk = NULL;
716                 log_error(_("%s: skipped: %s\n"), rov->d, g10_errstr(rc) );
717             }
718         }
719     }
720
721     if( !any_recipients && !opt.batch ) { /* ask */
722         char *answer=NULL;
723         int have_def_rec;
724
725         def_rec = default_recipient();
726         have_def_rec = !!def_rec;
727         if( !have_def_rec )
728             tty_printf(_(
729                 "You did not specify a user ID. (you may use \"-r\")\n\n"));
730         for(;;) {
731             rc = 0;
732             m_free(answer);
733             if( have_def_rec ) {
734                 answer = def_rec;
735                 def_rec = NULL;
736             }
737             else {
738                 answer = cpr_get_utf8("pklist.user_id.enter",
739                                        _("Enter the user ID: "));
740                 trim_spaces(answer);
741                 cpr_kill_prompt();
742             }
743             if( !*answer )
744                 break;
745             if( pk )
746                 free_public_key( pk );
747             pk = m_alloc_clear( sizeof *pk );
748             pk->pubkey_usage = use;
749             rc = get_pubkey_byname( NULL, pk, answer, NULL );
750             if( rc )
751                 tty_printf(_("No such user ID.\n"));
752             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use)) ) {
753                 if( have_def_rec ) {
754                     if (key_present_in_pk_list(pk_list, pk) == 0) {
755                         free_public_key(pk); pk = NULL;
756                         log_info(_("skipped: public key "
757                                    "already set as default recipient\n") );
758                     }
759                     else {
760                         PK_LIST r = m_alloc( sizeof *r );
761                         r->pk = pk; pk = NULL;
762                         r->next = pk_list;
763                         r->mark = 0;
764                         pk_list = r;
765                     }
766                     any_recipients = 1;
767                     break;
768                 }
769                 else {
770                     int trustlevel;
771
772                     rc = check_trust( pk, &trustlevel, NULL, NULL, NULL );
773                     if( rc ) {
774                         log_error("error checking pk of `%s': %s\n",
775                                                      answer, g10_errstr(rc) );
776                     }
777                     else if( (trustlevel & TRUST_FLAG_DISABLED) ) {
778                         tty_printf(_("Public key is disabled.\n") );
779                     }
780                     else if( do_we_trust_pre( pk, trustlevel ) ) {
781                         /* Skip the actual key if the key is already present
782                          * in the list */
783                         if (key_present_in_pk_list(pk_list, pk) == 0) {
784                             free_public_key(pk); pk = NULL;
785                             log_info(_("skipped: public key "
786                                        "already set with --encrypt-to\n") );
787                         }
788                         else {
789                             PK_LIST r;
790
791                             r = m_alloc( sizeof *r );
792                             r->pk = pk; pk = NULL;
793                             r->next = pk_list;
794                             r->mark = 0;
795                             pk_list = r;
796                         }
797                         any_recipients = 1;
798                         break;
799                     }
800                 }
801             }
802             m_free(def_rec); def_rec = NULL;
803             have_def_rec = 0;
804         }
805         m_free(answer);
806         if( pk ) {
807             free_public_key( pk );
808             pk = NULL;
809         }
810     }
811     else if( !any_recipients && (def_rec = default_recipient()) ) {
812         pk = m_alloc_clear( sizeof *pk );
813         pk->pubkey_usage = use;
814         rc = get_pubkey_byname( NULL, pk, def_rec, NULL );
815         if( rc )
816             log_error(_("unknown default recipient `%s'\n"), def_rec );
817         else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use)) ) {
818             PK_LIST r = m_alloc( sizeof *r );
819             r->pk = pk; pk = NULL;
820             r->next = pk_list;
821             r->mark = 0;
822             pk_list = r;
823             any_recipients = 1;
824         }
825         if( pk ) {
826             free_public_key( pk );
827             pk = NULL;
828         }
829         m_free(def_rec); def_rec = NULL;
830     }
831     else {
832         any_recipients = 0;
833         for(; remusr; remusr = remusr->next ) {
834             if( (remusr->flags & 1) )
835                 continue; /* encrypt-to keys are already handled */
836
837             pk = m_alloc_clear( sizeof *pk );
838             pk->pubkey_usage = use;
839             if( (rc = get_pubkey_byname( NULL, pk, remusr->d, NULL )) ) {
840                 free_public_key( pk ); pk = NULL;
841                 log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
842             }
843             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use )) ) {
844                 int trustlevel;
845
846                 rc = check_trust( pk, &trustlevel, NULL, NULL, NULL );
847                 if( rc ) {
848                     free_public_key( pk ); pk = NULL;
849                     log_error(_("%s: error checking key: %s\n"),
850                                                       remusr->d, g10_errstr(rc) );
851                 }
852                 else if( (trustlevel & TRUST_FLAG_DISABLED) ) {
853                     free_public_key(pk); pk = NULL;
854                     log_info(_("%s: skipped: public key is disabled\n"),
855                                                                     remusr->d);
856                 }
857                 else if( do_we_trust_pre( pk, trustlevel ) ) {
858                     /* note: do_we_trust may have changed the trustlevel */
859
860                     /* We have at least one valid recipient. It doesn't matters
861                      * if this recipient is already present. */
862                     any_recipients = 1;
863
864                     /* Skip the actual key if the key is already present
865                      * in the list */
866                     if (key_present_in_pk_list(pk_list, pk) == 0) {
867                         free_public_key(pk); pk = NULL;
868                         log_info(_("%s: skipped: public key already present\n"),
869                                                                     remusr->d);
870                     }
871                     else {
872                         PK_LIST r;
873                         r = m_alloc( sizeof *r );
874                         r->pk = pk; pk = NULL;
875                         r->next = pk_list;
876                         r->mark = 0;
877                         pk_list = r;
878                     }
879                 }
880                 else { /* we don't trust this pk */
881                     free_public_key( pk ); pk = NULL;
882                 }
883             }
884             else {
885                 free_public_key( pk ); pk = NULL;
886                 log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
887             }
888         }
889     }
890
891     if( !rc && !any_recipients ) {
892         log_error(_("no valid addressees\n"));
893         rc = G10ERR_NO_USER_ID;
894     }
895
896     if( rc )
897         release_pk_list( pk_list );
898     else
899         *ret_pk_list = pk_list;
900     return rc;
901 }
902
903
904
905 static int
906 algo_available( int preftype, int algo )
907 {
908     if( preftype == PREFTYPE_SYM ) {
909         if( algo == CIPHER_ALGO_TWOFISH )
910             return 0;  /* we don't want to generate Twofish messages for now*/
911         return algo && !check_cipher_algo( algo );
912     }
913     else if( preftype == PREFTYPE_HASH ) {
914         return algo && !check_digest_algo( algo );
915     }
916     else if( preftype == PREFTYPE_COMPR ) {
917         return !algo || algo == 1 || algo == 2;
918     }
919     else
920         return 0;
921 }
922
923 /****************
924  * Return -1 if we could not find an algorithm.
925  */
926 int
927 select_algo_from_prefs( PK_LIST pk_list, int preftype )
928 {
929     PK_LIST pkr;
930     u32 bits[8];
931     byte *pref = NULL;
932     size_t npref;
933     int i, j;
934     int compr_hack=0;
935     int any;
936
937     if( !pk_list )
938         return -1;
939
940     memset( bits, ~0, 8 * sizeof *bits );
941     for( pkr = pk_list; pkr; pkr = pkr->next ) {
942         u32 mask[8];
943
944         memset( mask, 0, 8 * sizeof *mask );
945         if( !pkr->pk->local_id ) { /* try to set the local id */
946             query_trust_info( pkr->pk, NULL );
947             if( !pkr->pk->local_id ) {
948                 log_debug("select_algo_from_prefs: can't get LID\n");
949                 continue;
950             }
951         }
952         if( preftype == PREFTYPE_SYM )
953             mask[0] |= (1<<2); /* 3DES is implicitly there */
954         m_free(pref);
955         pref = get_pref_data( pkr->pk->local_id, pkr->pk->namehash, &npref);
956         any = 0;
957         if( pref ) {
958            #if 0
959             log_hexdump("raw: ", pref, npref );
960            #endif
961             for(i=0; i+1 < npref; i+=2 ) {
962                 if( pref[i] == preftype ) {
963                     mask[pref[i+1]/32] |= 1 << (pref[i+1]%32);
964                     any = 1;
965                 }
966             }
967         }
968         if( (!pref || !any) && preftype == PREFTYPE_COMPR ) {
969             mask[0] |= 3; /* asume no_compression and old pgp */
970             compr_hack = 1;
971         }
972
973       #if 0
974         log_debug("mask=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
975                (ulong)mask[7], (ulong)mask[6], (ulong)mask[5], (ulong)mask[4],
976              (ulong)mask[3], (ulong)mask[2], (ulong)mask[1], (ulong)mask[0]);
977       #endif
978         for(i=0; i < 8; i++ )
979             bits[i] &= mask[i];
980       #if 0
981         log_debug("bits=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
982                (ulong)bits[7], (ulong)bits[6], (ulong)bits[5], (ulong)bits[4],
983              (ulong)bits[3], (ulong)bits[2], (ulong)bits[1], (ulong)bits[0]);
984       #endif
985     }
986     /* usable algorithms are now in bits
987      * We now use the last key from pk_list to select
988      * the algorithm we want to use. there are no
989      * preferences for the last key, we select the one
990      * corresponding to first set bit.
991      */
992     i = -1;
993     any = 0;
994     if( pref ) {
995         for(j=0; j+1 < npref; j+=2 ) {
996             if( pref[j] == preftype ) {
997                 if( (bits[pref[j+1]/32] & (1<<(pref[j+1]%32))) ) {
998                     if( algo_available( preftype, pref[j+1] ) ) {
999                         any = 1;
1000                         i = pref[j+1];
1001                         break;
1002                     }
1003                 }
1004             }
1005         }
1006     }
1007     if( !pref || !any ) {
1008         for(j=0; j < 256; j++ )
1009             if( (bits[j/32] & (1<<(j%32))) ) {
1010                 if( algo_available( preftype, j ) ) {
1011                     i = j;
1012                     break;
1013                 }
1014             }
1015     }
1016   #if 0
1017     log_debug("prefs of type %d: selected %d\n", preftype, i );
1018   #endif
1019     if( compr_hack && !i ) {
1020         /* selected no compression, but we should check whether
1021          * algorithm 1 is also available (the ordering is not relevant
1022          * in this case). */
1023         if( bits[0] & (1<<1) )
1024             i = 1;  /* yep; we can use compression algo 1 */
1025     }
1026
1027     m_free(pref);
1028     return i;
1029 }
1030
1031