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