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