See ChangeLog: Wed Aug 4 10:34:46 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                     PK_LIST r = m_alloc( sizeof *r );
755                     r->pk = pk; pk = NULL;
756                     r->next = pk_list;
757                     r->mark = 0;
758                     pk_list = r;
759                     any_recipients = 1;
760                     break;
761                 }
762                 else {
763                     int trustlevel;
764
765                     rc = check_trust( pk, &trustlevel, NULL, NULL, NULL );
766                     if( rc ) {
767                         log_error("error checking pk of `%s': %s\n",
768                                                      answer, g10_errstr(rc) );
769                     }
770                     else if( (trustlevel & TRUST_FLAG_DISABLED) ) {
771                         tty_printf(_("Public key is disabled.\n") );
772                     }
773                     else if( do_we_trust_pre( pk, trustlevel ) ) {
774                         PK_LIST r;
775
776                         r = m_alloc( sizeof *r );
777                         r->pk = pk; pk = NULL;
778                         r->next = pk_list;
779                         r->mark = 0;
780                         pk_list = r;
781                         any_recipients = 1;
782                         break;
783                     }
784                 }
785             }
786             m_free(def_rec); def_rec = NULL;
787             have_def_rec = 0;
788         }
789         m_free(answer);
790         if( pk ) {
791             free_public_key( pk );
792             pk = NULL;
793         }
794     }
795     else if( !any_recipients && (def_rec = default_recipient()) ) {
796         pk = m_alloc_clear( sizeof *pk );
797         pk->pubkey_usage = use;
798         rc = get_pubkey_byname( NULL, pk, def_rec, NULL );
799         if( rc )
800             log_error(_("unknown default recipient `%s'\n"), def_rec );
801         else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use)) ) {
802             PK_LIST r = m_alloc( sizeof *r );
803             r->pk = pk; pk = NULL;
804             r->next = pk_list;
805             r->mark = 0;
806             pk_list = r;
807             any_recipients = 1;
808         }
809         if( pk ) {
810             free_public_key( pk );
811             pk = NULL;
812         }
813         m_free(def_rec); def_rec = NULL;
814     }
815     else {
816         any_recipients = 0;
817         for(; remusr; remusr = remusr->next ) {
818             if( (remusr->flags & 1) )
819                 continue; /* encrypt-to keys are already handled */
820
821             pk = m_alloc_clear( sizeof *pk );
822             pk->pubkey_usage = use;
823             if( (rc = get_pubkey_byname( NULL, pk, remusr->d, NULL )) ) {
824                 free_public_key( pk ); pk = NULL;
825                 log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
826             }
827             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use )) ) {
828                 int trustlevel;
829
830                 rc = check_trust( pk, &trustlevel, NULL, NULL, NULL );
831                 if( rc ) {
832                     free_public_key( pk ); pk = NULL;
833                     log_error(_("%s: error checking key: %s\n"),
834                                                       remusr->d, g10_errstr(rc) );
835                 }
836                 else if( (trustlevel & TRUST_FLAG_DISABLED) ) {
837                     free_public_key(pk); pk = NULL;
838                     log_info(_("%s: skipped: public key is disabled\n"),
839                                                                     remusr->d);
840                 }
841                 else if( do_we_trust_pre( pk, trustlevel ) ) {
842                     /* note: do_we_trust may have changed the trustlevel */
843
844                     /* We have at least one valid recipient. It doesn't matters
845                      * if this recipient is already present. */
846                     any_recipients = 1;
847
848                     /* Skip the actual key if the key is already present
849                      * in the list */
850                     if (key_present_in_pk_list(pk_list, pk) == 0) {
851                         free_public_key(pk); pk = NULL;
852                         log_info(_("%s: skipped: public key already present\n"),
853                                                                     remusr->d);
854                     }
855                     else {
856                         PK_LIST r;
857                         r = m_alloc( sizeof *r );
858                         r->pk = pk; pk = NULL;
859                         r->next = pk_list;
860                         r->mark = 0;
861                         pk_list = r;
862                     }
863                 }
864                 else { /* we don't trust this pk */
865                     free_public_key( pk ); pk = NULL;
866                 }
867             }
868             else {
869                 free_public_key( pk ); pk = NULL;
870                 log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
871             }
872         }
873     }
874
875     if( !rc && !any_recipients ) {
876         log_error(_("no valid addressees\n"));
877         rc = G10ERR_NO_USER_ID;
878     }
879
880     if( rc )
881         release_pk_list( pk_list );
882     else
883         *ret_pk_list = pk_list;
884     return rc;
885 }
886
887
888
889 static int
890 algo_available( int preftype, int algo )
891 {
892     if( preftype == PREFTYPE_SYM ) {
893         if( algo == CIPHER_ALGO_TWOFISH )
894             return 0;  /* we don't want to generate Twofish messages for now*/
895         return algo && !check_cipher_algo( algo );
896     }
897     else if( preftype == PREFTYPE_HASH ) {
898         return algo && !check_digest_algo( algo );
899     }
900     else if( preftype == PREFTYPE_COMPR ) {
901         return !algo || algo == 1 || algo == 2;
902     }
903     else
904         return 0;
905 }
906
907 /****************
908  * Return -1 if we could not find an algorithm.
909  */
910 int
911 select_algo_from_prefs( PK_LIST pk_list, int preftype )
912 {
913     PK_LIST pkr;
914     u32 bits[8];
915     byte *pref = NULL;
916     size_t npref;
917     int i, j;
918     int compr_hack=0;
919     int any;
920
921     if( !pk_list )
922         return -1;
923
924     memset( bits, ~0, 8 * sizeof *bits );
925     for( pkr = pk_list; pkr; pkr = pkr->next ) {
926         u32 mask[8];
927
928         memset( mask, 0, 8 * sizeof *mask );
929         if( !pkr->pk->local_id ) { /* try to set the local id */
930             query_trust_info( pkr->pk, NULL );
931             if( !pkr->pk->local_id ) {
932                 log_debug("select_algo_from_prefs: can't get LID\n");
933                 continue;
934             }
935         }
936         if( preftype == PREFTYPE_SYM )
937             mask[0] |= (1<<2); /* 3DES is implicitly there */
938         m_free(pref);
939         pref = get_pref_data( pkr->pk->local_id, pkr->pk->namehash, &npref);
940         any = 0;
941         if( pref ) {
942            #if 0
943             log_hexdump("raw: ", pref, npref );
944            #endif
945             for(i=0; i+1 < npref; i+=2 ) {
946                 if( pref[i] == preftype ) {
947                     mask[pref[i+1]/32] |= 1 << (pref[i+1]%32);
948                     any = 1;
949                 }
950             }
951         }
952         if( (!pref || !any) && preftype == PREFTYPE_COMPR ) {
953             mask[0] |= 3; /* asume no_compression and old pgp */
954             compr_hack = 1;
955         }
956
957       #if 0
958         log_debug("mask=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
959                (ulong)mask[7], (ulong)mask[6], (ulong)mask[5], (ulong)mask[4],
960              (ulong)mask[3], (ulong)mask[2], (ulong)mask[1], (ulong)mask[0]);
961       #endif
962         for(i=0; i < 8; i++ )
963             bits[i] &= mask[i];
964       #if 0
965         log_debug("bits=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
966                (ulong)bits[7], (ulong)bits[6], (ulong)bits[5], (ulong)bits[4],
967              (ulong)bits[3], (ulong)bits[2], (ulong)bits[1], (ulong)bits[0]);
968       #endif
969     }
970     /* usable algorithms are now in bits
971      * We now use the last key from pk_list to select
972      * the algorithm we want to use. there are no
973      * preferences for the last key, we select the one
974      * corresponding to first set bit.
975      */
976     i = -1;
977     any = 0;
978     if( pref ) {
979         for(j=0; j+1 < npref; j+=2 ) {
980             if( pref[j] == preftype ) {
981                 if( (bits[pref[j+1]/32] & (1<<(pref[j+1]%32))) ) {
982                     if( algo_available( preftype, pref[j+1] ) ) {
983                         any = 1;
984                         i = pref[j+1];
985                         break;
986                     }
987                 }
988             }
989         }
990     }
991     if( !pref || !any ) {
992         for(j=0; j < 256; j++ )
993             if( (bits[j/32] & (1<<(j%32))) ) {
994                 if( algo_available( preftype, j ) ) {
995                     i = j;
996                     break;
997                 }
998             }
999     }
1000   #if 0
1001     log_debug("prefs of type %d: selected %d\n", preftype, i );
1002   #endif
1003     if( compr_hack && !i ) {
1004         /* selected no compression, but we should check whether
1005          * algorithm 1 is also available (the ordering is not relevant
1006          * in this case). */
1007         if( bits[0] & (1<<1) )
1008             i = 1;  /* yep; we can use compression algo 1 */
1009     }
1010
1011     m_free(pref);
1012     return i;
1013 }
1014
1015